◆ AI OBSERVABILITY

Weights & Biases Weave

v0.53.7 open-source

Weights & Biases Weave is an AI observability tool for tracing, debugging, and evaluating LLM applications and AI systems.

source ↗ rss ↗ last repo push Aug 20, 2026

llm.record({
  mediaAttachments: [...],
  responseId: 'resp_abc123',
  responseModel: 'gpt-4o',
  finishReasons: ['stop'],
  outputType: 'text'
});
const subagent = new Subagent({
  systemInstructions: 'You handle tool calls only.'
});
await subagent.record({ ... });
import { init } from 'weave';
await init({ projectName: 'my-project', useOTelv2: true });
import weave

obj = weave.ref('weave:///my-entity/my-project/object/my-model:v3').get()
import { withAttributes } from '@wandb/weave';

await withAttributes({ environment: 'prod', version: '2.1.0' }, async () => {
  // traced code here
});
import weave

weave.init('my-project')

call = weave.log_call(
    op_name='my_op',
    inputs={'prompt': 'Hello, world!'},
    output={'response': 'Hi there!'},
)
import weave

client = weave.init('my-project')
result = client.server.objs_query(
    weave.trace_server.trace_server_interface.ObjQueryReq(
        project_id='my-entity/my-project',
        filter=weave.trace_server.trace_server_interface.ObjectVersionFilter(
            exclude_base_object_classes=['Model', 'Dataset']
        )
    )
)
import weave

content = weave.Content.from_url('https://example.com/sample-audio.mp3')
import weave

content = weave.Content.from_data_url('data:image/png;base64,iVBORw0KGgo...')
serialised = content.model_dump_json()
restored = weave.Content.model_validate_json(serialised)
import weave

weave.init('my-project')
client = weave.get_client()
print(client)
import weave
from weave.integrations.smolagents import WeaveInstrumentor

WeaveInstrumentor().instrument()
weave.init('my-project')

# your smolagents agent code here
import * as weave from 'weave';

class MyAgent {
  @weave.op
  async run(input: string): Promise<string> {
    return `processed: ${input}`;
  }
}
import weave

weave.init('my-project')
dataset = weave.ref('weave:///my-entity/my-project/object/my-dataset:latest').get()
dataset.add_rows([{'input': 'hello', 'expected': 'world'}, {'input': 'foo', 'expected': 'bar'}])
import weave
import dspy

weave.init('dspy-project')

lm = dspy.LM('openai/gpt-4o-mini')
dspy.configure(lm=lm)

class MyModule(dspy.Module):
    def __init__(self):
        self.predict = dspy.Predict('question -> answer')
    def forward(self, question):
        return self.predict(question=question)

module = MyModule()
result = module(question='What is DSPy?')
print(result.answer)
import weave

client = weave.init('my-project')
# ... your traced code ...
client.finish()
import weave

weave.init('my-project', global_attributes={'pipeline': 'rag-v2', 'environment': 'production'})
calls = client.calls(filter={'op_name': 'my_op'})
print(len(calls))
import weave

@weave.op(tracing_sample_rate=0.1)
def my_inference(prompt: str) -> str:
    ...
evaluation = weave.Evaluation(name='my-rag-eval-v1', dataset=dataset, scorers=[scorer])
await evaluation.evaluate(model)
import weave

weave.init('my-project')
dataset = weave.ref('my-dataset:latest').get()

for row in dataset:
    print(row)
import weave
import openai

weave.init('my-project')
client = openai.OpenAI()

completion = client.beta.chat.completions.parse(
    model='gpt-4o-mini',
    messages=[{'role': 'user', 'content': 'Extract: John is 30 years old.'}],
    response_format=MySchema,
)
import weave

@weave.op(display_name='My Summarizer')
def summarize(text: str) -> str:
    return text[:100]
import weave

def on_finish(result):
    print('Op finished with:', result)

@weave.op(finish_handler=on_finish)
def my_op(x: int) -> int:
    return x * 2
import weave

@weave.op(display_name='My Summarizer')
def summarize(text: str) -> str:
    return text[:100]
import weave

def on_finish(call):
    print('Op finished:', call)

@weave.op()
def my_op(x: int) -> int:
    return x * 2

my_op.finish_handler = on_finish
import weave

weave.require_current_call()  # raises if no active call context
import weave
import anthropic

weave.init('my-project')
client = anthropic.Anthropic()

with client.messages.stream(
    model='claude-3-opus-20240229',
    max_tokens=256,
    messages=[{'role': 'user', 'content': 'Summarize the water cycle.'}]
) as stream:
    for text in stream.text_stream:
        print(text, end='', flush=True)
import weave
from PIL import Image

weave.init('my-project')

@weave.op()
def process_image(path: str):
    img = Image.open(path)
    return img  # PIL Image is now serialized natively by Weave

process_image('screenshot.png')
import weave

@weave.op()
def my_llm_call(prompt: str) -> str:
    return "response"

result, call = my_llm_call.call("What is the capital of France?")
print(call.id)
import weave

@weave.op()
def process(data: str) -> str:
    current = weave.get_current_call()
    print(current.id)
    return data
import weave
import anthropic

weave.init('my-anthropic-project')

client = anthropic.Anthropic()
message = client.messages.create(
    model='claude-3-opus-20240229',
    max_tokens=1024,
    messages=[{'role': 'user', 'content': 'Hello, Claude!'}]
)

Summary

Weights & Biases Weave is an open-source toolkit for developing Generative AI applications that allows logging and debugging language model inputs, outputs, and traces, and building evaluations. Since it requires a Weights & Biases account, a free tier is available, and it is used as a Python library imported into other code. It is for application developers working with LLMs, and its documentation positions it alongside existing tooling for Generative AI development. The project maintains active development with installation instructions available via pip.

Weights & Biases Weave is an AI observability tool for tracing, debugging, and evaluating LLM applications and AI systems.

What Weights & Biases Weave answers

What types of external API calls can be traced?

calls to services like OpenAI, Anthropic, and Google AI Studio

What versions of Python are required to run the tool?

Python 3.10 or higher

Does the tool require any persistent local configuration or database setup?

No, it requires only the initial setup of the W&B account and Python package installation

What information does the resulting trace capture?

The inputs and outputs of all decorated functions, forming a traceable execution tree

Command line

composed command

option surface across analysed releases

options at that release added, per release removed, per release

option	found in	since	description

Values are placeholders taken from each option’s declared default. Nothing is executed here — the output shown is a recording of a run that already happened.

Release history

v0.53.7 Aug 27, 2026 · issue 009

Weave v0.53.7 adds PII detection/redaction, an Agent PII policy field, and optional score-tracing control for imperative evals.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.53.7 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.53.7
```
- ›Adds an optional pii_policy field on Agent spans to declare a PII handling policy per agent.
- ›Adds PII detection and redaction helpers for sanitizing sensitive data flowing through traces.
- ›Allows score tracing to be disabled in imperative evaluations, giving finer control over what gets recorded.
- ›Adds monitoring tables for tags, enabling tag-based observability queries.
- ›Records the agent span that invoked a call in the TypeScript SDK, linking calls to their originating agent.
v0.53.6 Aug 13, 2026 · issue -006

Weave v0.53.6 adds Claude subagent tracing, private-IP remote scoring, parent-call span columns, and agent-span call linking.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.53.6 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.53.6
```
- ›Adds record_error to Python GenAI spans, enabling structured error recording on agent spans.
- ›Adds parent-call columns to spans, surfacing the caller context directly in span data.
- ›Adds tracing for Claude Agent SDK subagents (Python), including nested and background subagents (TypeScript).
- ›Links @weave.op calls and TypeScript weave op calls to the agent spans they produced, connecting ops to their downstream agent activity.
- ›Records the agent span that invoked a call, making invocation provenance queryable in traces.
+1 moreshow less
- ›Accepts JSON tool values in the TypeScript client, broadening tool input compatibility.
v0.53.6 Aug 13, 2026 · issue 002

Weave v0.53.6 adds Claude subagent tracing, private-IP remote scoring, parent-call span columns, and record_error for GenAI spans.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.53.6 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.53.6
```
- ›Adds record_error to Python GenAI spans, enabling structured error recording on agent spans.
- ›Adds parent-call columns to spans, surfacing the invoking agent span for every call.
- ›Traces Claude Agent SDK subagents (Python), including nested and background subagents (TypeScript), giving full visibility into multi-agent Claude workflows.
- ›Links @weave.op calls (Python and TypeScript) to the agent spans they produced, connecting decorated functions to their downstream agent activity.
- ›Accepts JSON tool values in the TypeScript client, broadening the range of tool call payloads that can be traced.
+1 moreshow less
- ›Records the agent span that invoked a call, enabling upstream attribution in trace trees.
v0.53.4 Jul 31, 2026 · issue -019

Weave v0.53.4 adds custom runtime registration APIs, Azure workload identity support, and expanded Claude Agent SDK tracing including image prompts.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.53.4 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.53.4
```
- ›Adds a custom runtime registration API (Python) and a custom runtime SDK wrapper — enabling programmatic registration of custom execution environments.
- ›Adds a custom runtime TypeScript SDK wrapper, bringing the same custom runtime capability to the TypeScript SDK.
- ›Supports Azure workload identity for authentication, removing the need for explicit credential secrets in Azure-hosted deployments.
- ›Traces Claude Agent SDK image prompts, extending multimodal visibility into Claude Agent workflows.
- ›Records turn output messages in agent traces, capturing full multi-turn conversation output for replay and debugging.
v0.53.4 Jul 31, 2026 · issue 002

Weave v0.53.4 adds custom runtime registration API, Azure workload identity support, and Claude Agent SDK image prompt tracing.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.53.4 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.53.4
```
- ›Adds custom runtime registration API (Python) for registering custom execution environments programmatically.
- ›Adds custom runtime SDK wrapper (Python) and TypeScript SDK wrapper for integrating custom runtimes in both languages.
- ›Supports Azure workload identity authentication for Azure-backed deployments.
- ›Traces Claude Agent SDK image prompts, extending visual input coverage to the Claude Agent integration.
- ›Records turn output messages in agent traces for fuller multi-turn conversation visibility.
v0.53.3 Jul 31, 2026 · issue -019

Weave v0.53.3 adds agent dashboard persistence, eval linking, feedback totals, agent event emission, and reasoning_effort on the completions API.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.53.3 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.53.3
```
- ›Exposes reasoning_effort parameter on the completions API for controlling model reasoning depth.
- ›Adds totals to feedback queries, enabling aggregate feedback metrics in a single response.
- ›Adds a persisted agent dashboard object type for storing and retrieving agent dashboards.
- ›Links stamped agent spans to evaluation results for traceability between agent runs and evals.
- ›Emits agent events for insights, enabling downstream analysis of agent behavior.
+1 moreshow less
- ›Separates turn input and output messages in the TypeScript SDK for finer-grained conversation tracing.
v0.53.3 Jul 31, 2026 · issue 002

Weave v0.53.3 adds reasoning_effort to completions API, agent event emission, persisted agent dashboards, and feedback query totals.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.53.3 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.53.3
```
- ›Exposes reasoning_effort parameter on the completions API for controlling model reasoning intensity.
- ›Links stamped agent spans to evaluation results, connecting agent traces to eval outcomes.
- ›Adds a persisted agent dashboard object type for storing agent dashboards across sessions.
- ›Adds totals aggregation to feedback queries, enabling summary metrics over feedback data.
- ›Emits agent events for insights, enabling downstream analysis of agent behavior.
+1 moreshow less
- ›Separates turn input and output messages in TypeScript tracing for clearer multi-turn conversation structure.
v0.53.2 Jul 16, 2026 · issue -034

Weave v0.53.2 adds agent span feedback, eval metadata stamping, conversation signal filtering, server-side ingest sampling, and Base64/Data URL content ref conversion.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.53.2 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.53.2
```
- ›Adds SubAgent.start_subagent() method and nests LLM/Tool/SubAgent spans under Turn and SubAgent in the Python SDK for structured agent trace hierarchies.
- ›Adds column_visibility field to ComparisonViewDefinition to control column display in comparison views.
- ›Adds scorer_trace_id field denormalized onto feedback records, linking scorer traces directly to feedback entries.
- ›Adds first-class SDK feedback for agent spans and turns, enabling programmatic feedback submission on agent traces.
- ›Adds agent eval span fields and stamps eval metadata onto agent spans for evaluation traceability.
+7 moreshow less
- ›Adds server-side ingest sampling for the spans model, letting operators reduce span volume at the server level.
- ›Adds Base64 and Data URL content ref conversion, enabling binary/media content to be stored and referenced as content objects.
- ›Adds ObjDeleteRes response that reports deleted versions when objects are deleted.
- ›Adds backend support to filter agent conversations by signals (tags and ratings).
- ›Exports the API contract (export api contract) for the Weave server.
- ›Defaults the JavaScript client to the calls_complete ingest path for improved write performance.
- ›Nests LLM/Tool/SubAgent spans under a SubAgent in the TypeScript SDK (TS SDK v0.16.3).
v0.53.1 Jul 2, 2026 · issue -048

Weave v0.53.1 expands the TypeScript agent API with Turn.record(), SubAgent.record(), richer LLM.record() fields, and adds predict-only cost totals to eval summaries.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.53.1 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.53.1
```
└──▷ USE IT
Record a completed LLM call with rich metadata including media attachments and finish reasons for detailed tracing.
javascript
```
llm.record({
  mediaAttachments: [...],
  responseId: 'resp_abc123',
  responseModel: 'gpt-4o',
  finishReasons: ['stop'],
  outputType: 'text'
});
```
Record a subagent span to capture nested agent execution within a parent conversation trace.
javascript
```
const subagent = new Subagent({
  systemInstructions: 'You handle tool calls only.'
});
await subagent.record({ ... });
```
- ›Adds userMessage and systemInstructions parameters when creating Turns in the TypeScript API.
- ›Adds agent_id, agent_description, and agent_version parameters when creating Turns in the TypeScript API.
- ›Adds agent_id, agent_description, and agent_version parameters when creating Conversations in the TypeScript API.
- ›Adds systemInstructions parameter when creating Subagents in the TypeScript API.
- ›Adds systemInstructions parameter when creating LLMs in the TypeScript API.
+7 moreshow less
- ›Adds SubAgent.record() method to the TypeScript API.
- ›Adds Turn.record() method to the TypeScript API.
- ›Extends LLM.record() to accept mediaAttachments, responseId, responseModel, finishReasons, and outputType fields in the TypeScript API.
- ›Adds predict-only cost total to the eval results summary.
- ›Propagates agent identity defaults (agent_id, agent_description, agent_version) from Conversation to turns automatically.
- ›Removes the ddtrace dependency by inlining DogStatsD directly in datadog.py, reducing the library's dependency footprint.
- ›Parallelizes attachment uploads on all writes, improving throughput for multi-attachment traces.
v0.53.0 Jul 2, 2026 · issue -048

Weave v0.53.0 adds agent-oriented APIs to WeaveClient, OTel session attributes, eval metadata tagging, and a new wandb.agent_user_feedback feedback type.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.53.0 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.53.0
```
└──▷ USE IT
Enable the next-generation OTel pipeline when initializing Weave in a TypeScript project.
javascript
```
import { init } from 'weave';
await init({ projectName: 'my-project', useOTelv2: true });
```
- ›Adds getAgents, getAgentVersions, getAgentSpans, getAgentTurn, and getAgentTurns functions to the TypeScript WeaveClient for querying agent data programmatically.
- ›Adds useOTelv2 setting to the TypeScript init() call to opt into the next-generation OTel pipeline.
- ›Adds gen_ai.conversation.id as an OTel attribute on all spans in the @openai/agents integration, enabling conversation-level trace correlation.
- ›Adds gen_ai.agent.name as an OTel attribute on all spans in the @openai/agents integration, enabling agent-level trace correlation.
- ›Adds integration OTel attributes to all spans produced by the @openai/agents integration.
+14 moreshow less
- ›Adds wandb.agent_user_feedback feedback type for capturing end-user feedback on agent interactions.
- ›Adds agent_name_override support for OTel invoke_agent spans, allowing generic agent name overrides.
- ›Adds query-time cost data to agent spans and stats APIs.
- ›Adds support for session-level span attributes on traces.
- ›Extends the /agent_search endpoint with additional filtering and query capabilities.
- ›Tags declarative evaluation child calls with evaluation metadata in both Python and TypeScript.
- ›Adds predict-only token total to evaluation results summary.
- ›Supports match any and match all filtering options on evaluations.
- ›Adds OTel tracing primitives to weave.trace_server.
- ›Adds an in-memory fake trace server with full call ingestion, deletion, TTL, OTel export, object CRUD, feedback, costs, threads, annotation queues, and eval/scoring support — enabling fully offline testing without a live backend.
- ›Sends trace_id on calls-ingest requests that lack one, improving trace continuity for partial payloads.
- ›Sends trace_id on call-end ingest messages from the TypeScript client.
- ›Batches traced completion-call span writes for improved throughput at scale.
- ›Buckets project_id partition keys for HPA-friendly horizontal scaling of the trace ingestion path.
└──▷ BREAKING ON UPGRADE
- !The WeaveClient value is no longer exported from the TypeScript package — only the WeaveClient type is exported. Any code that imported WeaveClient as a value will break.
v0.52.43 Jun 15, 2026 · issue -065

Weave v0.52.43 adds OpenAI Agents SDK span emission, aggregate feedback endpoint, set_attributes/add_event on span types, and playground trace routing.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.43 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.43
```
- ›Adds set_attributes and add_event methods to Tool, LLM, SubAgent, and Turn span types in both the Python and TypeScript SDKs.
- ›New aggregate feedback API endpoint for summarising feedback across calls.
- ›Emits invoke_agent, execute_tool, chat, handoff, guardrail, transcription, speech, speech_group, mcp_list_tools, and custom spans for the OpenAI Agents SDK (TypeScript).
- ›Emits message data on chat spans for the OpenAI Agents SDK (TypeScript).
- ›Supports post-hoc start/end time overrides on GenAI spans (TypeScript).
+5 moreshow less
- ›Pushes traces from playgrounds to the spans table.
- ›Adds a database migration to include agent columns in the feedback table.
- ›Formalises integration-tracking call attributes for consistent attribution across integrations.
- ›Adds claude-fable-5 to model providers and cost tracking.
- ›Performance improvement: bounded conversation message previews for grouped spans query, extending the calls_query_stats fast path with a time-window filter, and a flat-sum fast path for unfiltered storage stats.
v0.52.42 Jun 2, 2026 · issue -078

Weave v0.52.42 adds Google ADK and Claude Agents OTEL integrations, annotation queue SDK helpers, rescore support, and richer token tracking.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.42 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.42
```
- ›Adds Turn.setAttribute and Turn.addEvent methods to the TypeScript SDK for attaching custom metadata and events to agent turns.
- ›Adds annotation queue SDK helpers (Python) for programmatic management of annotation queues.
- ›Adds cache_creation and cache_read input token tracking to LLM call records.
- ›Adds reasoning output token tracking to LLM call records.
- ›Adds grouped span custom attribute distributions for analyzing spans across calls.
+9 moreshow less
- ›Supports multi-alias semantic convention keys, allowing a single field to be matched by multiple semconv aliases.
- ›Adds typed scorer_* feedback columns and agent_monitor type with query filters to the feedback table.
- ›Implements rescore in trace server backends, enabling re-evaluation of existing scored calls.
- ›Supports scorer_* fields for wandb.runnable scorers.
- ›Adds preliminary Google ADK integration for tracing Google Agent Development Kit calls.
- ›Adds OpenAI Agents integration v2 with improved tracing coverage.
- ›Adds initial Claude Agents SDK OTEL integration for tracing Anthropic agent workflows.
- ›Adds automatic eval linking to the TypeScript SDK.
- ›Session SDK now respects global Weave settings.
v0.52.41 May 28, 2026 · issue -083

Weave v0.52.41 links Gen AI OTel spans to Evals, adds agent custom attribute schema queries, and auto-writes 'latest' aliases on object creation.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.41 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.41
```
- ›Adds WEAVE_INSECURE_DISABLE_SSL environment variable support to the OTLP Exporter for deployments requiring SSL bypass.
- ›Links Gen AI spans to Evals automatically via a new OTel span processor, enabling eval association without manual wiring.
- ›Adds agent custom attribute schema queries, allowing structured querying of agent-specific attributes.
- ›Writes an explicit latest alias on every obj_create call, so the most recent object version is always addressable by alias.
- ›Infers JSON filter casts in the feedback query path, improving filter expressiveness for feedback data.
v0.52.40 May 14, 2026 · issue -097

Weave v0.52.40 adds agent span ref kinds, feedback folding via include_feedback, dynamic JSON filter cast inference, and agent numeric stats buckets.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.40 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.40
```
- ›Adds include_feedback parameter to fold feedback into agent chat-view responses.
- ›Adds agent_turn, agent_conversation, and agent_span ref kinds for finer-grained agent trace classification.
- ›Adds a helper for querying feedback by agent target refs.
- ›Adds agent numeric stats buckets for aggregating agent span metrics.
- ›Infers dynamic JSON filter casts automatically, reducing manual type-casting in ClickHouse trace queries.
+1 moreshow less
- ›Reduces per-op overhead in async tracing for lower-latency instrumentation.
v0.52.39 May 11, 2026 · issue -100

Weave v0.52.39 adds a GenAI observability schema with OTel span emission, agent-scoring events, and Session SDK ergonomics for manually-instrumented agents.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.39 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.39
```
- ›Adds weave.score_agent_spans event emitted for GenAI turn_ended spans, enabling automatic scoring of agent turns in the observability pipeline.
- ›Adds TTL settings GET and POST API endpoints for managing trace time-to-live configuration.
- ›Adds agent span stats API endpoint for querying aggregated statistics over agent spans.
- ›Introduces a GenAI observability schema, extraction layer, and query layer for structured GenAI trace data.
- ›Wires OTel span emission into the Session SDK, expanding GenAI OTel coverage for agent sessions.
+2 moreshow less
- ›Adds Session SDK ergonomics for manually-instrumented agents, making it easier to instrument custom agent code.
- ›Adds Grok 4.3 model costs to the built-in cost tracking table.
v0.52.38 May 5, 2026 · issue -106

Weave v0.52.38 adds GEPA integration, Session SDK, prompt registry linking, server-side eval pagination, and agent observability.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.38 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.38
```
- ›Adds linkPromptToRegistry support to the Python SDK, enabling prompts to be linked directly to the Weights & Biases prompt registry.
- ›Adds server-side sort, filter, and pagination for /eval_results, reducing client-side data transfer for large evaluation result sets.
- ›Adds GEPA (Generalized Evaluation Pipeline Architecture) integration.
- ›Stubs out a Session SDK API surface for session-level observability.
- ›Adds an agent observability table migration, laying the database foundation for agent-level tracking.
+3 moreshow less
- ›Activates TTL L2 Redis cache for improved read performance.
- ›Auto opts-in calls_complete on wandb-entity projects.
- ›Makes wandb an optional dependency, allowing the library to be used without a full W&B installation.
v0.52.37 Apr 17, 2026 · issue -124

Weave v0.52.37 adds cached-token cost tracking, OTel convention updates, and Node SDK prompt-registry linking.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.37 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.37
```
- ›Adds linkPromptToRegistry to the Node (TypeScript) SDK for linking prompts to the registry.
- ›Implements cache token cost calculations and updates integrations to track cached token usage in cost reporting.
- ›Updates OpenTelemetry integration to support the most recent OTel conventions.
- ›Exports ClassifierMonitor from the top-level __init__.py for direct import.
v0.52.36 Apr 1, 2026 · issue -140

Weave v0.52.36 adds username resolution on calls, text-based eval results, and lazy ref resolution without explicit client init.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.36 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.36
```
└──▷ USE IT
Fetch a stored Weave object by ref without initialising a client first — useful in scripts that only need to read a single artifact.
python
```
import weave

obj = weave.ref('weave:///my-entity/my-project/object/my-model:v3').get()
```
- ›Adds WEAVE_INSECURE_DISABLE_SSL environment variable to disable SSL verification, matching the wandb pattern.
- ›Supports ref.get() without requiring an explicit client init, enabling lighter-weight ref resolution workflows.
- ›Adds support for text-based eval results in evaluations.
- ›Enables loading evaluations with more than 1000 calls to predict_and_score.
v0.52.35 Mar 19, 2026 · issue -153

Weave v0.52.35 adds WAL mechanics, feedback stats queries, wildcard ref filtering, and a Redis client configuration.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.35 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.35
```
- ›Adds WAL (write-ahead log) mechanics for improved trace durability.
- ›Adds a feedback stats query capability for aggregating feedback data.
- ›Supports wildcard filtering on input/output refs when querying calls.
- ›Adds Redis client and connection configuration support.
- ›Allows Ref.uri to be used as a property (without parentheses), in addition to Ref.uri().
+1 moreshow less
- ›Adds client-side digest calculation plumbing to reduce server-side load.
v0.52.33 Mar 12, 2026 · issue -159

Weave v0.52.33 adds automatic instrumentation for the OpenAI Agents Realtime API and new SDK/HTTP support for tags and aliases.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.33 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.33
```
- ›Adds HTTP interface models and SDK client methods for tags and aliases, exposing new bindings via RemoteHTTPTraceServer.
- ›Adds automatic instrumentation for the OpenAI Agents Realtime API, capturing tool calls, audio data, user-submitted text input, and user voice input.
v0.52.32 Mar 12, 2026 · issue -159

Weave v0.52.32 adds SDK client methods and HTTP bindings for tags/aliases, plus initial OpenAI Agents Realtime API support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.32 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.32
```
- ›Adds SDK client methods and HTTP bindings for tags and aliases management.
- ›Adds initial support for the OpenAI Agents Realtime API.
v0.52.31 Mar 10, 2026 · issue -161

Weave v0.52.31 adds Claude agents integration, Fireworks provider support, trace server backend for tags and aliases, and timestamps/TTFT for realtime tracing.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.31 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.31
```
- ›Adds Claude agents integration for tracing Anthropic agent workflows.
- ›Adds Fireworks as a supported LLM provider.
- ›Adds trace server backend support for tags and aliases on traced objects.
- ›Adds timestamps and time-to-first-token (TTFT) tracking for realtime tracing.
- ›Supports merged scorers in monitors.
v0.52.30 Mar 10, 2026 · issue -161

Weave v0.52.30 adds a score-backfill endpoint, Gemini tracking in the TS SDK, and sharded distributed calls for better query performance.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.30 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.30
```
- ›Adds an endpoint to backfill scores for existing evaluation records.
- ›Adds Gemini model tracking support to the TypeScript SDK.
- ›Shards the distributed calls table by trace_id or project_id for improved query performance at scale.
- ›Eliminates CTE usage for calls_complete queries, reducing query overhead.
v0.52.29 Feb 27, 2026 · issue -171

Weave v0.52.29 adds unfinished-call metadata to usage APIs, a python-magic MIME backend, real-time thread tracking, tags/aliases schema, and a new eval_results/query API.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.29 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.29
```
- ›Adds eval_results/query API endpoint for retrieving structured evaluation data.
- ›Adds metadata about unfinished calls to usage APIs, surfacing in-flight call state.
- ›Adds tags and aliases schema to the data model.
- ›Adds python-magic backend for MIME-type detection.
- ›Adds thread tracking and usage reporting for real-time (OpenAI Realtime API) calls.
+2 moreshow less
- ›Adds API for editing annotation queue metadata.
- ›Adds claude-sonnet 4.6 to the supported model providers list.
v0.52.28 Feb 14, 2026 · issue -184

Weave v0.52.28 adds OpenAI Realtime GA support, $lt/$lte ORM filters, and resource attributes for W&B vars via OTel.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.28 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.28
```
- ›Adds $lt and $lte comparison operators to the ORM query layer, enabling range-based filtering of calls.
- ›Adds support for resource attributes for W&B vars via OpenTelemetry integration.
- ›New OTel projects now write to the calls_complete table for improved call stats and usage tracking.
- ›Promotes OpenAI Realtime tracing support to GA.
- ›Exposes wb_run and storage data fields on calls.
+1 moreshow less
- ›Adds Vertex AI as a supported LLM provider.
v0.52.26 Feb 3, 2026 · issue -195

Weave v0.52.26 adds usage stats APIs, a performance flag, Anthropic parse patching, and column ordering for saved views.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.26 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.26
```
- ›Adds GET /trace/usage endpoint to dynamically aggregate usage data across traces.
- ›Adds GET /calls/usage endpoint to dynamically bulk-aggregate usage data across calls.
- ›Adds column_order field to SavedViewDefinition to control column ordering in saved views.
- ›Adds patching support for Anthropic parse calls, extending Weave's Anthropic integration.
- ›Introduces a new opt-in flag for improved query performance on distributed ClickHouse clusters (PREWHERE optimization).
+2 moreshow less
- ›Adds support for filtering calls by annotation queue.
- ›Allows LLM-as-a-Judge evaluations to specify image and video scoring targets.
v0.52.24 Jan 15, 2026 · issue -214

Weave v0.52.24 adds PII redaction field exclusions, audio support in LLMAsAJudgeScorer, op kinds/colors, and safe base64 auto-conversion in the trace server.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.24 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.24
```
- ›Adds redact_pii_exclude_fields setting to selectively exempt specific fields from PII redaction.
- ›Adds audio support to LLMAsAJudgeScorer, enabling evaluation of audio-containing traces.
- ›Adds op kinds and color tagging for operations via Add support for op kinds and colors, with built-in kinds for integrations to visually distinguish call types in the UI.
- ›Auto-converts base64 data safely in the trace server, expanding the range of payloads that can be stored without manual encoding steps.
- ›Updates the Leaderboard schema to support overhaul features, broadening what metrics and comparisons can be displayed.
+1 moreshow less
- ›Adds a helper method for TypeScript SDK prompt management.
v0.52.23 Jan 8, 2026 · issue -221

Weave v0.52.23 adds logfire/pydantic-ai parsing, annotation queue APIs, and broader LangChain autopatching.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.23 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.23
```
- ›Adds new APIs for annotation queue management, including queue stats (Annotation Queues Stats API) and querying queue items, backed by a new database migration for a queue-based call annotation system.
- ›Adds input and output parsing for logfire pydantic-ai instrumentation, enabling structured trace data from pydantic-ai spans.
- ›Improves autopatching for common LangChain imports, broadening automatic tracing coverage.
- ›Adds GPT-5.2 and gpt-image-1.5 models to the playground.
- ›Allows the client to enforce a minimum trace server version for compatibility checks.
+1 moreshow less
- ›Exposes storage parameters in weave_client.get_calls().
v0.52.22 Jan 8, 2026 · issue -221

Weave v0.52.22 adds prompt and template variable persistence on LLMStructuredCompletionModels.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.22 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.22
```
- ›Saves and reuses prompts and template variables on LLMStructuredCompletionModels, enabling structured prompt tracking across LLM calls.
- ›Adds configurable HTTP timeout for Weave's HTTP client.
v0.52.20 Nov 26, 2025 · issue -264

Weave v0.52.20 adds Bedrock Agents tracing, TypeScript withAttributes, OpenAI x-request-id tracking, prompt vars in streaming completions, and ObjectRef.fromUri.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.20 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.20
```
└──▷ USE IT
Add custom attributes to a span in the TypeScript SDK to enrich traces with runtime metadata.
typescript
```
import { withAttributes } from '@wandb/weave';

await withAttributes({ environment: 'prod', version: '2.1.0' }, async () => {
  // traced code here
});
```
- ›Adds completions_create_stream support for passing prompt and template vars directly, enabling prompt-managed streaming completions.
- ›Implements ObjectRef.fromUri method to construct ObjectRef instances from Weave URIs.
- ›Tracks x-request-id headers from the OpenAI Responses API, surfacing request correlation IDs in traces.
- ›Adds withAttributes to the TypeScript SDK for attaching arbitrary attributes to spans.
- ›Adds integration tracing for AWS Bedrock Agents.
└──▷ BREAKING ON UPGRADE
- !Minimum Python version raised to 3.10; setups running Python 3.8 or 3.9 will break on upgrade.
v0.52.16 Nov 7, 2025 · issue -283

Weave v0.52.16 adds dataclass redaction support and lets users associate traces with a specific W&B Run.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.16 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.16
```
- ›Adds support for redacting dataclasses, enabling sensitive fields in dataclass objects to be scrubbed from traces.
- ›Allows users to specify a W&B Run to associate traces with at initialization time.
v0.52.15 Nov 6, 2025 · issue -284

Weave v0.52.15 adds batch object creation and OTEL span op generation.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.15 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.15
```
- ›Implements obj_create_batch for creating multiple objects in a single batch operation.
- ›Adds op creation for OTEL spans, enabling tracing operations to be generated from OpenTelemetry span data.
v0.52.14 Oct 31, 2025 · issue -290

Weave v0.52.14 adds imperative call logging, new CRUD endpoints for Models/EvaluationRuns/Predictions/Scores, and OTEL wb_run_id attribution.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.14 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.14
```
└──▷ USE IT
Log a call imperatively — useful when you cannot wrap a function with a decorator, such as when tracing third-party code or building a custom instrumentation layer.
python
```
import weave

weave.init('my-project')

call = weave.log_call(
    op_name='my_op',
    inputs={'prompt': 'Hello, world!'},
    output={'response': 'Hi there!'},
)
```
- ›Adds weave.log_call as an imperative call logger, enabling programmatic call logging without decorators.
- ›Adds new CRUD API endpoints for interacting with Models.
- ›Adds new CRUD API endpoints for interacting with EvaluationRuns, Predictions, and Scores.
- ›Adds wb_run_id attribute to OTEL spans for linking traces to W&B runs.
- ›Adds a simple row-logging method to EvaluationLogger for recording individual evaluation results.
+1 moreshow less
- ›Supports properly retrieving a dataset in the TypeScript SDK.
v0.52.11 Oct 23, 2025 · issue -298

Weave v0.52.11 adds CRUD endpoints for Ops, Datasets, Scorers, and Evaluations, plus incremental score aggregation and a fire-and-forget EvaluationLogger API.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.11 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.11
```
- ›Adds new CRUD endpoints for interacting with Ops, enabling programmatic create/read/update/delete of Op objects via the trace server API.
- ›Adds new CRUD endpoints for interacting with Datasets, enabling programmatic create/read/update/delete of Dataset objects via the trace server API.
- ›Adds new CRUD endpoints for interacting with Scorers, enabling programmatic create/read/update/delete of Scorer objects via the trace server API.
- ›Adds new CRUD endpoints for interacting with Evaluations, enabling programmatic create/read/update/delete of Evaluation objects via the trace server API.
- ›Adds a fire-and-forget API for EvaluationLogger with promise chain coordination in the TypeScript SDK, enabling non-blocking evaluation logging.
+3 moreshow less
- ›Implements incremental score aggregation and update mechanisms in EvaluationLogger.
- ›Supports context propagation in EvaluationLogger, allowing trace context to flow through evaluation workflows.
- ›Introduces ImperativeEval in the TypeScript SDK (Part 1), enabling imperative-style evaluation authoring in TS.
v0.52.9 Oct 10, 2025 · issue -311

Weave v0.52.9 adds OpenAI Realtime support, image tracing, OTEL user ID parsing, custom call-page content, and a new object query filter.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.9 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.9
```
└──▷ USE IT
Filter out base object classes when listing objects in the Weave object store to see only user-defined objects.
python
```
import weave

client = weave.init('my-project')
result = client.server.objs_query(
    weave.trace_server.trace_server_interface.ObjQueryReq(
        project_id='my-entity/my-project',
        filter=weave.trace_server.trace_server_interface.ObjectVersionFilter(
            exclude_base_object_classes=['Model', 'Dataset']
        )
    )
)
```
- ›Adds exclude_base_object_classes to the objects query filter, letting callers exclude base object classes when querying the object store.
- ›Supports OpenAI Realtime API tracing — conversations over the realtime websocket interface are now captured as Weave traces.
- ›Adds image support to the trace server so image data can be stored and retrieved as part of call inputs/outputs.
- ›Parses user ID from OTEL spans, surfacing per-user attribution in OpenTelemetry-sourced traces.
- ›Enables user code to define custom content displayed on a call's detail page.
v0.52.8 Sep 17, 2025 · issue -333

Weave v0.52.8 adds from_data_url, JSON serialization, and URL-based loading for the Content type.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.8 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.8
```
└──▷ USE IT
Load a remote image or file directly into a Weave Content object for tracing or evaluation pipelines.
python
```
import weave

content = weave.Content.from_url('https://example.com/sample-audio.mp3')
```
Round-trip a Content object through JSON serialization, e.g. to store or transmit binary content in a structured trace payload.
python
```
import weave

content = weave.Content.from_data_url('data:image/png;base64,iVBORw0KGgo...')
serialised = content.model_dump_json()
restored = weave.Content.model_validate_json(serialised)
```
- ›Adds from_data_url class method and JSON serialization support to the Content type, enabling round-trip serialization of binary content objects.
- ›Adds from_url constructor to the Content type, allowing Content objects to be instantiated directly from a remote URL.
v0.52.7 Sep 12, 2025 · issue -338

Weave v0.52.7 adds implicit patching, verifier integration, object deletion API, and a new GLM-4.5 model.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.7 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.7
```
- ›Adds methods to delete all versions of an object from the Weave object store.
- ›Adds implicit patching support, complementing the new explicit patching capability, to control how integrations are applied.
- ›Adds integration with verifiers for tracing and evaluating verifier-based workflows.
- ›Adds zai-org/GLM-4.5 model support.
└──▷ BREAKING ON UPGRADE
- !Removes Pydantic v1 support; setups relying on Pydantic v1 will break on upgrade.
v0.52.5 Aug 28, 2025 · issue -353

Weave v0.52.5 adds user-controlled key redaction, a wandb integration, and parallel table uploads for faster tracing.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.5 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.5
```
- ›Adds user control over which keys are redacted from traced payloads via feat(weave): Give user control over what keys to redact.
- ›Adds a wandb integration, enabling direct linking between Weave traces and W&B runs.
- ›Parallel table uploads via table_create_from_digests significantly reduce latency when logging large tables.
- ›Significantly improves import time by deferring imports until needed, reducing startup overhead for traced applications.
- ›Respects the WANDB_ENTITY environment variable in weave.init(), enabling entity selection without code changes.
v0.52.4 Aug 23, 2025 · issue -358

Weave v0.52.4 adds time-to-first-token for OpenAI streaming, improved DSPy integration, parallel scorer execution, and DeepSeek v3 cost tracking.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.4 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.4
```
- ›Adds time-to-first-token metric tracking for OpenAI streaming endpoints.
- ›Improves DSPy integration with expanded tracing and observability support.
- ›Runs evaluation scorers in parallel, reducing evaluation wall-clock time.
- ›Adds DeepSeek v3.1 to model providers and cost tracking.
v0.52.1 Aug 19, 2025 · issue -362

Weave v0.52.1 adds OTEL thread parsing, custom eval attributes, OpenAI inference in the playground, and GPT-5/Claude 4.1 cost support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.52.1 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.52.1
```
- ›Adds thread_id parsing and is_turn handling to the OTEL ingestion pipeline, enabling richer multi-turn conversation tracing from OpenTelemetry spans.
- ›Adds custom eval attributes to EvaluationLogger, letting callers attach arbitrary metadata to evaluation runs.
- ›Adds error-state handling to the imperative eval logger so failed evaluations are captured and surfaced rather than silently dropped.
- ›Adds OpenAI inference support to playground providers, enabling direct OpenAI model calls from the Weave playground UI.
- ›Adds cost and provider support for GPT-5 and Claude 4.1 models.
+3 moreshow less
- ›Allows omitting the coreweave/ prefix on hosted model strings, simplifying model references for CoreWeave-hosted deployments.
- ›Enables Kafka client authentication for dedicated deployments.
- ›Adds client methods to retrieve evaluations and scores programmatically.
└──▷ BREAKING ON UPGRADE
- !Removes support for the google-generativeai package integration; users must migrate to the google-genai (google-genai) integration.
v0.51.59 Jul 25, 2025 · issue -364

Weave v0.51.59 adds Thread API filtering, generic content support, document views for LangChain/ChromaDB, and a major call-filter performance boost.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.59 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.59
```
- ›Adds Thread API support for filtering by thread ID via the filter parameter.
- ›Adds filtering of calls by object references using CTE queries, enabling more precise trace queries.
- ›Adds generic content type support to Weave, broadening the range of artifacts and data that can be tracked.
- ›Adds document view rendering for LangChain and ChromaDB integrations in the trace detail UI.
- ›Massively improves filter_calls query performance by forcing index use on the backend — unlocks practical filtering at scale.
+5 moreshow less
- ›Adds a link to navigate directly to the trace detail view from trace listings.
- ›Adds a feature flag to expose the Threads feature in the UI.
- ›Adapts the OpenAI integration to support the new OpenAI export format.
- ›Adds grok 4 and MoonshotAI Kimi K2 models to the Playground.
- ›Adds stream parameter support to the new completions endpoint.
v0.51.56 Jul 10, 2025 · issue -364

Weave v0.51.56 adds saved views for the Threads page and customizable chart names in the trace table.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.56 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.56
```
- ›Adds saved view support for the Threads page, allowing practitioners to persist and reuse filtered or configured thread views.
- ›Enables customizable chart names in the trace table UI.
- ›Adds the ability for remote_http_trace_server to accept additional headers.
- ›Unpins the LiteLLM dependency from DSPy, allowing use of current LiteLLM versions alongside DSPy integrations.
v0.51.55 Jul 9, 2025 · issue -364

Weave v0.51.55 adds HuggingFace Datasets integration, online evals, JSON Schema in Playground, LangChain ChatView, and a new thread_id column.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.55 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.55
```
- ›Adds thread_id column to the calls table, stats view, and call compare view for tracking conversation threads.
- ›Reads the inference service base URL from an environment variable, enabling custom endpoint configuration without code changes.
- ›Adds JSON Schema support in the Playground for structured output configuration.
- ›Adds bidirectional conversion between Hugging Face Datasets and weave.Dataset (HF.Datasets <-> weave.Dataset).
- ›Adds a 'Remove all ops' option in the monitor ops dropdown for bulk deselection.
+5 moreshow less
- ›Includes ingestion size in the call compare view.
- ›Lifts the feature gate for online evaluations, making monitors/online evals generally available in multi-tenant SaaS.
- ›Adds a dedicated LangChain ChatView for rendering LangChain traces in the chat UI.
- ›Adds thinking/reasoning support in message streaming within the Playground UI.
- ›Adds usage banners to the Playground UI.
v0.51.54 Jun 16, 2025 · issue -365

Weave v0.51.54 adds OpenAI Responses API tracing, a Chat View for Responses, and online LLM-as-a-judge evals.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.54 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.54
```
└──▷ USE IT
Retrieve the active Weave client after initialization — useful for inspection or passing the client to downstream utilities without re-initializing.
python
```
import weave

weave.init('my-project')
client = weave.get_client()
print(client)
```
- ›Adds get_client() top-level function to retrieve the active Weave client programmatically.
- ›Supports the OpenAI Responses API in the OpenAI SDK integration, enabling tracing and logging of Responses API calls.
- ›Adds a Chat View for OpenAI Responses API traces in the Weave UI.
- ›Introduces online evaluations with LLM-as-a-judge scorers, enabling continuous scoring of live production calls.
v0.51.52 Jun 11, 2025 · issue -365

Weave v0.51.52 adds end-to-end online monitoring, Anthropic SDK support, OpenAI API endpoint tracking, and an updated LLMStructuredCompletionModel.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.52 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.52
```
- ›Adds end-to-end online monitoring capability for tracking live model behavior in production.
- ›Adds support for the Anthropic SDK, enabling tracing and logging of Anthropic model calls.
- ›Adds OpenAI API endpoint tracking to capture and observe requests made through the OpenAI API.
- ›Updates LLMStructuredCompletionModel to inherit from Model and adds a predict function, enabling it to participate in Weave's standard model evaluation and tracing workflows.
- ›Adds model catalog and inference service UI on the Weave side, surfacing inference service metadata in the interface.
v0.51.48 May 23, 2025 · issue -366

Weave v0.51.48 adds smolagents integration, OTEL chat view, evaluation comparison reports, and a WEAVE_LOG_LEVEL setting.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.48 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.48
```
└──▷ USE IT
Automatically trace a smolagents agent run and send spans to Weave for inspection.
python
```
import weave
from weave.integrations.smolagents import WeaveInstrumentor

WeaveInstrumentor().instrument()
weave.init('my-project')

# your smolagents agent code here
```
- ›Adds WEAVE_LOG_LEVEL environment variable to control logging verbosity and consolidates terminal output into a common module.
- ›Implements smolagents integration for tracing smolagents-based workflows.
- ›Adds first-class descendant_error state to surface errors that occur in child/descendant calls.
- ›Supports chat view rendering for OpenTelemetry (OTEL) traces in the UI.
- ›New Evaluation Report feature lets users compare and analyze evaluation results in tabular (pivot) form with regression filters and a callout area on the eval compare page.
+1 moreshow less
- ›TypeScript SDK: call handles can now be returned from traced functions.
v0.51.47 May 15, 2025 · issue -366

Weave v0.51.47 adds MP3/PDF media support, decorator-based op tracking for TypeScript, Google ADK OTEL keys, and a new descendant_error call state.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.47 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.47
```
└──▷ USE IT
Track a TypeScript class method as a Weave op using the new decorator syntax, so every invocation is logged as a traced call.
typescript
```
import * as weave from 'weave';

class MyAgent {
  @weave.op
  async run(input: string): Promise<string> {
    return `processed: ${input}`;
  }
}
```
- ›Adds decorator support for weave.op in the TypeScript SDK, enabling class and object method tracking via @weave.op decorator syntax.
- ›Adds descendant_error as a first-class call state on the Python side, allowing callers to distinguish traces where a child call failed.
- ›Adds Google ADK OpenTelemetry keys to the OTEL server for tracing Google Agent Development Kit workloads.
- ›Adds MP3 audio playback support in the Weave frontend for media logged to traces.
- ›Adds a PDF viewer and generic file handling in the UI for viewing file attachments within calls.
+1 moreshow less
- ›Shows object storage size on the project overview page.
v0.51.46 May 9, 2025 · issue -366

Weave v0.51.46 adds Mistral chat integration, a saved models frontend, project stats API backend, and an option to disable auto-summarize in imperative evals.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.46 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.46
```
- ›Adds option to disable auto-summarize in imperative evaluations via a new parameter on the evaluation call.
- ›Adds Mistral chat integration (feat(weave): Mistral chat) with tool-calling support including streaming.
- ›Adds Mistral as a provider option in the playground UI.
- ›Adds a saved models frontend view in the UI.
- ›Adds backend support for the project stats API.
+1 moreshow less
- ›Adds a drawer to the providers tab in the UI.
v0.51.45 May 7, 2025 · issue -366

Weave v0.51.45 adds Dataset.add_rows, weave.dataset.select, video I/O support, Vercel OTEL integration, Saved Views, and project-level storage size display.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.45 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.45
```
└──▷ USE IT
Append new rows to an existing dataset without rewriting it from scratch — useful when incrementally collecting evaluation examples.
python
```
import weave

weave.init('my-project')
dataset = weave.ref('weave:///my-entity/my-project/object/my-dataset:latest').get()
dataset.add_rows([{'input': 'hello', 'expected': 'world'}, {'input': 'foo', 'expected': 'bar'}])
```
- ›Adds Dataset.add_rows() helper method for efficiently appending rows to an existing dataset.
- ›Adds weave.dataset.select for querying/selecting from a dataset.
- ›Adds Vercel OTEL conventions integration for tracing spans originating from Vercel deployments.
- ›Adds support for video input and output in the SDK.
- ›Adds Saved Views in the UI, letting users persist and switch between customized table/filter configurations.
+6 moreshow less
- ›Adds bulk object delete functionality in the UI.
- ›Adds line-wrap control buttons to the UI for toggling line wrapping in trace/call views.
- ›Displays storage size per trace and total project file size in the UI and backend stats query.
- ›Communicates trace endpoint errors to users in the UI.
- ›Adds trace ref inclusion when adding a trace to a dataset from the UI.
- ›Adds a dynamically updated mods list pulled from GitHub in the UI.
v0.51.44 Apr 24, 2025 · issue -367

Weave v0.51.44 adds a Monitor SDK class for online monitoring, imperative eval improvements, and storage-size visibility in object details.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.44 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.44
```
- ›Adds Monitor class to the SDK (Online Monitoring I), enabling programmatic monitoring of live model behaviour from Python.
- ›Exposes name config and read-only props on EvaluationLogger for finer control over imperative evaluation logging.
- ›Adds UI and API improvements for Imperative Evals, including individual scores in the Imperative Evals UI.
- ›Supports emitting storage size in the object details view via trace_server, making artifact footprint visible per object.
- ›Refactors OpenTelemetry (OTel) parsing to standardize fields across ingested spans.
+2 moreshow less
- ›Enables editing of list-valued dataset cells in the UI.
- ›Includes notes and reactions when adding calls to datasets.
v0.51.43 Apr 18, 2025 · issue -367

Weave v0.51.43 adds imperative evaluation APIs, MCP python-sdk support, OTEL/OpenInference semantic conventions, and promotes Playground to GA.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.43 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.43
```
- ›Adds Imperative Evaluation APIs enabling programmatic evaluation workflows without decorator-based setup.
- ›Adds support for the MCP python-sdk integration, enabling tracing of Model Context Protocol tool calls.
- ›Adds semantic conventions parsing for OpenTelemetry (OTEL) and OpenInference trace formats.
- ›Adds boolean all, boolean any, and number isInteger ops to weave_query.
- ›Adds status filtering to the trace/calls UI.
+6 moreshow less
- ›Displays trace storage size in the Trace view and on the call summary page.
- ›Adds ability to include annotations when adding calls to a dataset.
- ›Adds query shortcuts for an empty query panel.
- ›Adds ability to add API keys in the Playground drawer; Playground promoted to GA.
- ›Allows selection of a custom step metric in the stepper panel.
- ›Conditionally surfaces trace metadata in ObjectView.
v0.51.42 Apr 8, 2025 · issue -367

Weave v0.51.42 adds AWS Bedrock Guardrails scoring and OpenTelemetry tracing support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.42 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.42
```
- ›Adds OpenTelemetry (otel) tracing support, enabling trace export via the OTLP protocol.
- ›Adds AWS Bedrock Guardrails integration with a new Scorer for evaluating LLM outputs against Bedrock safety policies.
- ›Adds a default datetime filter on the trace table UI for scoped, time-bounded trace browsing.
v0.51.41 Apr 3, 2025 · issue -367

Weave v0.51.41 adds DSPy 2.x and Google GenAI integrations, custom LLM providers in the playground, JSONL/TSV dataset uploads, and storage-size API support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.41 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.41
```
└──▷ USE IT
Trace a DSPy 2.x pipeline end-to-end, including custom DSPy modules, inside a Weave project.
python
```
import weave
import dspy

weave.init('dspy-project')

lm = dspy.LM('openai/gpt-4o-mini')
dspy.configure(lm=lm)

class MyModule(dspy.Module):
    def __init__(self):
        self.predict = dspy.Predict('question -> answer')
    def forward(self, question):
        return self.predict(question=question)

module = MyModule()
result = module(question='What is DSPy?')
print(result.answer)
```
- ›Adds caption attribute to ImageArtifactFileRef in weave_query, exposing image captions as a queryable field.
- ›Adds storage size to the API via a new capability on calls (adds api capability to include storage size), letting callers retrieve payload size information programmatically.
- ›Adds a new Google GenAI integration (weave.integrations for google-genai) for automatic tracing of Google Generative AI SDK calls.
- ›Adds a DSPy 2.x integration for tracing DSPy pipelines, including support for custom DSPy modules.
- ›Adds custom providers table to the Providers tab and enables custom providers in the Playground, allowing teams to configure and use their own LLM endpoints.
+8 moreshow less
- ›Adds create_with_completion tracking in the Instructor integration.
- ›Supports JSON, JSONL, and TSV file uploads for dataset creation in the UI.
- ›Supports zooming images in the lightbox up to 5x natural pixel size.
- ›Adds .cif file support in Weave molecule panels.
- ›Adds OTel-style trace/span IDs for calls, enabling interoperability with OpenTelemetry-instrumented systems.
- ›Emits a warning when Weave is used without calling weave.init, helping users catch misconfigured setups early.
- ›Introduces a runs history plots stepper in the app for navigating multi-step run history plots.
- ›Formats long durations with minutes in the trace tree view for improved readability.
v0.51.39 Mar 24, 2025 · issue -368

Weave v0.51.39 adds a CrewAI integration and inline serializers for custom type handling.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.39 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.39
```
- ›Adds inline serializers, enabling custom serialization logic to be defined directly alongside type definitions.
- ›Adds a CrewAI integration for tracing and observability of CrewAI agent workflows.
- ›Improves dataset download performance by fetching rows containing images in parallel.
v0.51.38 Mar 21, 2025 · issue -368

Weave v0.51.38 adds OpenAI Agents SDK integration, a new trace navigation system, latency/status sorting, and W&B Run display in the calls grid.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.38 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.38
```
- ›Adds OpenAI Agents SDK integration for tracing agent workflows.
- ›Adds basic support for OpenAI Responses API.
- ›Enables sorting and filtering in the trace table by latency, status, and trace_name.
- ›Adds a new trace navigation system, replacing the previous trace tree UI.
- ›Allows displaying W&B Run information as columns in the calls grid.
+2 moreshow less
- ›Improves WebP image support in trace views.
- ›Adds a Providers overview page to the UI.
v0.51.37 Mar 17, 2025 · issue -368

Weave v0.51.37 adds CSV dataset upload support in the UI.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.37 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.37
```
- ›Adds the ability to upload a dataset directly from a CSV file via the UI.
v0.51.36 Mar 6, 2025 · issue -368

Weave v0.51.36 adds non-SaaS BYOB support, client.finish, user-configurable retry settings, and gpt-4.5-preview/deepseek in the playground.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.36 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.36
```
└──▷ USE IT
Explicitly finish a Weave client session after all traces are logged, ensuring the queue is flushed before the process exits.
python
```
import weave

client = weave.init('my-project')
# ... your traced code ...
client.finish()
```
- ›Adds client.finish method to explicitly flush and finalize the Weave client, replacing repeated flush calls.
- ›Adds minimal setup for non-SaaS Bring Your Own Backend (BYOB) deployments.
- ›Adds gpt-4.5-preview and deepseek as selectable models in the Weave playground.
- ›Enables user-configurable retry settings for the trace client.
- ›Makes the internal queue size configurable via server settings.
v0.51.35 Feb 25, 2025 · issue -369

Weave v0.51.35 adds pandas export for calls, dataset ingestion from calls in the UI, and Pydantic subclass JSON support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.35 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.35
```
- ›Adds option to export calls to pandas, with a costs option included in the export.
- ›Adds to_json handling for Pydantic model subclasses, enabling proper serialization of custom model types.
- ›Adds ability to add call(s) to a dataset directly from the app UI, with field select/deselect-all support in the dataset mapping step.
- ›Adds Claude 3.7 and o3 mini models to the playground.
- ›Hides trace tree children when a node has more than 100 children, improving rendering performance for large traces.
v0.51.34 Feb 20, 2025 · issue -369

Weave v0.51.34 adds HuggingFace inference integration, new LLM scorers, PII redaction via Presidio, and global attributes on init.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.34 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.34
```
└──▷ USE IT
Attach environment or pipeline metadata to every traced call in a session without tagging each call individually.
python
```
import weave

weave.init('my-project', global_attributes={'pipeline': 'rag-v2', 'environment': 'production'})
```
- ›Adds PresidioEntityRecognitionGuardrail for PII entity recognition using Microsoft Presidio, with support for custom_entities via PresidioScorer.
- ›Adds PII redaction capability for Weave traces using Microsoft Presidio.
- ›Adds PromptInjectionLLMGuardrail (refactored) for detecting prompt injection attacks.
- ›Adds option to set global attributes in weave.init, allowing trace-level metadata to be attached to all calls in a session.
- ›Adds new built-in scorers: WeaveHallucinationScorer, WeaveTrustScorer, a Coherence Scorer, and a Context Relevance Scorer.
+6 moreshow less
- ›Implements integration with the HuggingFace inference client, enabling Weave tracing for HuggingFace-hosted model calls.
- ›Refactors LLM cost and client tracking to use litellm instead of provider-specific clients.
- ›Adds an 'Apply' button to column header popups in the calls table UI.
- ›Extends runs history step slider to include history tables from all runs.
- ›Adds dataset sorting while editing datasets in the UI.
- ›Uses new iframe postMessage protocol and surfaces iframe errors in the UI.
v0.51.33 Feb 5, 2025 · issue -369

Weave v0.51.33 adds prompt injection detection guardrails, a disk cache for server functions, and a Scorer logs viewer.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.33 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.33
```
- ›Adds an LLM-assisted prompt injection detection guardrail to the Guardrails module.
- ›Implements a disk cache for idempotent server functions, reducing redundant computation.
- ›Allows derived columns to be used as variables in the Weave expression editor.
- ›Passes derived columns as new variables onto the stack in panel plots.
- ›Adds a Runs History Tables Scrubber for navigating run history.
+2 moreshow less
- ›Adds a basic viewer for a Scorer's logs in the UI.
- ›Adds a lightbox for images in the UI.
v0.51.32 Jan 29, 2025 · issue -370

Weave v0.51.32 adds artifact ref links in the UI, predefined keyboard bindings, and the ability to disable context capture.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.32 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.32
```
- ›Adds support for disabling capture of context (PR #3523).
- ›Adds predefined keyboard binding controls to the UI (PR #3390).
- ›Adds artifact ref links in the UI, enabling navigation to artifact references directly (PR #3500).
v0.51.31 Jan 24, 2025 · issue -370

Weave v0.51.31 adds Dataset construction from Calls, pandas bridging helpers, and an in-UI dataset editing interface.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.31 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.31
```
- ›Adds helper methods to convert between pandas DataFrames and Weave datasets, bridging pandas workflows with Weave's dataset primitives.
- ›Allows Dataset to be constructed directly from Calls, enabling trace data to be turned into a dataset without manual transformation.
- ›New dataset editing UI lets users modify dataset contents directly in the browser.
v0.51.30 Jan 22, 2025 · issue -370

Weave v0.51.30 adds autopatch opt-out support and a configurable grid page size in the UI.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.30 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.30
```
- ›Adds the ability to disable autopatch, giving users programmatic control over whether Weave automatically patches supported integrations.
- ›Adds configurable page size in the grid view, letting users control how many rows are displayed per page.
- ›Adds Amazon Bedrock to the Weave sidebar as a tracked integration surface.
v0.51.29 Jan 17, 2025 · issue -370

Weave v0.51.29 adds Bedrock integration, JPEG/PNG tracking, SDK object deletion, and improved ref-getting.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.29 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.29
```
- ›Adds weave.delete (delete objects and ops from the SDK) so practitioners can programmatically remove objects and ops without going through the UI.
- ›Adds Amazon Bedrock support via a new integration, enabling tracing of Bedrock model calls.
- ›Adds support for tracking JPEG and PNG images natively, expanding logged artifact types beyond text and structured data.
- ›Improves ref-getting ergonomics, making it more convenient to retrieve references to tracked objects in the SDK.
- ›Tracks the creating user on object creation, surfacing the user column in objects and ops tables in the UI.
+1 moreshow less
- ›Non-admin users can now delete objects through the UI object deletion interface.
v0.51.28 Jan 14, 2025 · issue -370

Weave v0.51.28 adds code redaction, global post-processing options, UI object deletion, and guardrails/monitoring via scorer application.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.28 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.28
```
└──▷ USE IT
Use len() on a CallsIter result to quickly count matching traced calls without materializing the full list.
python
```
calls = client.calls(filter={'op_name': 'my_op'})
print(len(calls))
```
- ›Adds global post-processing options for controlling how captured data is transformed before storage.
- ›Enables call.feedback.add() for annotation-type feedback on traced calls.
- ›Supports len() on CallsIter, making iteration over call results more Pythonic.
- ›Implements public 'apply scorer' capability, the MVP foundation for Guardrails and Monitoring workflows.
- ›Adds ability to delete objects directly from the UI.
+3 moreshow less
- ›Makes annotation values in the traces table clickable.
- ›Adds annotation spec name column to the feedback grid.
- ›Higher-precision formatting for token and cost displays in the UI.
v0.51.27 Jan 3, 2025 · issue -370

Weave v0.51.27 adds op configuration for autopatched integrations and ChatNVIDIA autopatch support in LangChain.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.27 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.27
```
- ›Adds op configuration support for autopatched functions across remaining integrations, enabling per-function tracing customization.
- ›Adds autopatching of ChatNVIDIA in LangChain, extending Weave's automatic tracing to NVIDIA-hosted models.
- ›Creates an API client for the trace server in weave_query, enabling programmatic access to trace data.
- ›Adds a mods page and menu item for wandb admins.
v0.51.25 Dec 17, 2024 · issue -371

Weave v0.51.25 adds op-level trace sampling, OpenAI moderation/embeddings tracking, and op configuration for autopatched functions.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.25 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.25
```
└──▷ USE IT
Limit trace volume in high-throughput pipelines by sampling only a fraction of op calls.
python
```
import weave

@weave.op(tracing_sample_rate=0.1)
def my_inference(prompt: str) -> str:
    ...
```
- ›Adds tracing_sample_rate param to weave.op to control what fraction of op calls are traced.
- ›Supports op configuration for autopatched functions, starting with OpenAI integrations.
- ›Adds tracking for OpenAI moderation and embeddings API calls.
- ›Adds an error details button in the UI for expanded error inspection.
v0.51.24 Dec 11, 2024 · issue -371

Weave v0.51.24 adds named evals, AzureOpenAI scorer support, op code capture, and Anthropic Chat View support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.24 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.24
```
└──▷ USE IT
Give an evaluation a human-readable name so it is easy to find in the Weave UI rather than relying on auto-generated IDs.
python
```
evaluation = weave.Evaluation(name='my-rag-eval-v1', dataset=dataset, scorers=[scorer])
await evaluation.evaluate(model)
```
- ›Adds AzureOpenAI support for Scorers, enabling Azure-hosted models to be used as LLM judges in evaluations.
- ›Adds option to name Weave evaluations, with automatic memorable name generation when no name is specified.
- ›Exposes a simple API to retrieve the captured source code for an op.
- ›Supports Anthropic calls in the Chat View UI for inspecting traced conversations.
v0.51.23 Dec 3, 2024 · issue -371

Weave v0.51.23 adds VertexAI and Google GenAI integrations, Bedrock LLMs in Playground, and a new Scorers section in the side nav.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.23 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.23
```
- ›Adds send_message patching for the Google GenAI SDK to capture traces automatically.
- ›Implements VertexAI integration for tracing calls made through the VertexAI SDK.
- ›Adds Amazon Bedrock LLMs to the Playground for interactive model testing.
- ›Adds a new scorers section to the side nav bar, enabling creation and viewing of scorers in the UI.
- ›Increases call start/end timestamp resolution to microseconds for finer-grained trace timing.
+1 moreshow less
- ›Adds an explicit object preparation hook for types that require custom serialization (e.g. PIL.Image.Image).
v0.51.22 Nov 21, 2024 · issue -372

Weave v0.51.22 adds object comparison in the UI and introduces simple prompt classes.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.22 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.22
```
- ›Adds simple prompt classes for structured prompt management.
- ›Adds object comparison view in the UI for side-by-side inspection of Weave objects.
v0.51.20 Nov 19, 2024 · issue -372

Weave v0.51.20 adds Dataset iteration, OpenAI beta parse API tracking, up/down call navigation, and a number-parsing string op.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.20 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.20
```
└──▷ USE IT
Iterate directly over a published Weave Dataset to feed rows into an eval pipeline without manual index access.
python
```
import weave

weave.init('my-project')
dataset = weave.ref('my-dataset:latest').get()

for row in dataset:
    print(row)
```
Track structured outputs from the OpenAI beta parse API so parsed responses appear as typed calls in Weave.
python
```
import weave
import openai

weave.init('my-project')
client = openai.OpenAI()

completion = client.beta.chat.completions.parse(
    model='gpt-4o-mini',
    messages=[{'role': 'user', 'content': 'Extract: John is 30 years old.'}],
    response_format=MySchema,
)
```
- ›Adds tracking support for the OpenAI beta parse API via the openai integration.
- ›Adds a weave_call_id field to LLM completions, plus an option to disable tracking for individual LLM completion calls.
- ›Makes Dataset iterable, enabling direct Python iteration over Weave datasets in user code.
- ›Adds a new string op to weave_query that parses numbers containing thousands and decimal separators.
- ›Adds a feedback replace endpoint that performs a purge and create in a single step.
+5 moreshow less
- ›Adds backend support for on-demand LLM Judges (Online Evals Part 1).
- ›Adds ActionSpec as a known registered type (previously ActionDefinition).
- ›Adds a hidden Scorers page to the UI for managing scorer configurations.
- ›Enables up/down keyboard navigation across calls from the peek drawer on the calls page.
- ›Adds a playground page with call stats, LLM dropdown, chat input, stop-sequence editor, function editor, response editor, and settings drawer with sliders.
v0.51.19 Nov 4, 2024 · issue -372

Weave v0.51.19 adds project-level leaderboards, single-call retrieval from the TS client, and dict serialization of inputs/outputs.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.19 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.19
```
- ›Adds option to retrieve a single call by ID from the TypeScript client (weave_ts).
- ›Enables dictify serialization of call inputs and outputs, making them accessible as plain dictionaries.
- ›Adds project-level leaderboards for comparing model/evaluation performance across a project.
v0.51.18 Nov 1, 2024 · issue -372

Weave v0.51.18 adds an initial scorer suite, a JS SDK, a completions endpoint, leaderboard support, and trace page charts.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.18 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.18
```
- ›Adds completions/create endpoint to the Weave backend, enabling programmatic LLM completion requests through the Weave API.
- ›Adds an initial JS SDK (weave_ts) for instrumenting JavaScript/TypeScript applications with Weave tracing.
- ›Adds JS SDK code options to the 'Use' tab in the UI, surfacing JavaScript examples alongside existing language options.
- ›Adds an initial suite of scorers and refactors weave/flow, providing built-in evaluation scorers for LLM outputs.
- ›Adds client and backend support for Leaderboards, enabling ranking and comparison of model evaluation results.
+3 moreshow less
- ›Adds charts to the traces page for visual performance and usage analysis of traced calls.
- ›Adds byte usage display to the summary tab and object page, surfacing storage consumption metrics in the UI.
- ›Adds simple language detection for the code browser, automatically identifying code language in the UI.
v0.51.17 Oct 17, 2024 · issue -373

Weave v0.51.17 adds NotDiamond integration, paginated table queries, display_name for ops, a finish handler for ops, and a Callout UI component.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.17 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.17
```
└──▷ USE IT
Attach a human-readable label to a traced op so it appears clearly in the Weave UI instead of the raw function name.
python
```
import weave

@weave.op(display_name='My Summarizer')
def summarize(text: str) -> str:
    return text[:100]
```
Run logic after an op finishes — useful for logging, cleanup, or post-processing traced outputs.
python
```
import weave

def on_finish(result):
    print('Op finished with:', result)

@weave.op(finish_handler=on_finish)
def my_op(x: int) -> int:
    return x * 2
```
- ›Adds display_name field to ops, allowing human-readable labels to be attached to traced operations.
- ›Exposes TableQueryStats and paginated table queries via a new streaming interface, enabling efficient traversal of large tables.
- ›Adds a finish handler for ops, giving callers a hook to run logic when an op completes.
- ›Adds NotDiamond integration for tracing calls through the NotDiamond routing API.
- ›Minimizes blocking calls during tracing to reduce latency overhead in instrumented code.
+2 moreshow less
- ›Adds a new Callout UI component to the frontend component library.
- ›Improves table query performance by splitting metadata and value retrieval in object queries.
v0.51.16 Oct 16, 2024 · issue -373

Weave v0.51.16 adds NotDiamond integration, paginated table queries, op display names, finish handlers, and async-friendly tracing.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.16 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.16
```
└──▷ USE IT
Give a traced op a human-readable label that appears in the Weave UI instead of the raw function name.
python
```
import weave

@weave.op(display_name='My Summarizer')
def summarize(text: str) -> str:
    return text[:100]
```
Run post-processing logic (e.g. logging, cleanup) immediately after an op finishes, using the new finish handler hook.
python
```
import weave

def on_finish(call):
    print('Op finished:', call)

@weave.op()
def my_op(x: int) -> int:
    return x * 2

my_op.finish_handler = on_finish
```
- ›Exposes TableQueryStats and paginated table queries via a new streaming interface, enabling efficient traversal of large datasets without loading all rows into memory.
- ›Adds display_name field to ops, letting practitioners label operations with human-readable names distinct from their code identifiers.
- ›Adds a finish handler for ops, allowing post-execution callbacks to be registered on op completion.
- ›Minimizes blocking calls during tracing, reducing latency impact on instrumented code paths.
- ›New NotDiamond integration for automatic LLM routing tracking within Weave traces.
+1 moreshow less
- ›New Callout UI component available in the frontend component library.
v0.51.14 Oct 9, 2024 · issue -373

Weave v0.51.14 adds paginated table queries, TableQueryStats exposure, minimized blocking during tracing, and a finish handler for ops.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.14 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.14
```
- ›Exposes TableQueryStats and supports paginated table queries, enabling callers to retrieve large tables in pages rather than a single blocking fetch.
- ›Minimizes blocking calls while tracing, reducing latency impact on instrumented code paths.
- ›Adds a finish handler for ops, allowing post-execution hooks to be registered on operations.
- ›New Callout UI component added to the frontend component library.
v0.51.12 Sep 30, 2024 · issue -374

Weave v0.51.12 adds optional feedback inclusion in calls export.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.12 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.12
```
- ›Adds the ability to optionally include feedback data in calls export.
v0.51.10 Sep 26, 2024 · issue -374

Weave v0.51.10 adds an Instructor integration for structured output tracing.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.10 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.10
```
- ›Adds an Instructor integration, enabling tracing of structured LLM outputs produced via the Instructor library.
v0.51.8 Sep 20, 2024 · issue -374

Weave v0.51.8 adds pagination/sorting to object and table APIs, code-capture control, row digests on table mutations, and a chat view for calls.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.8 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.8
```
└──▷ USE IT
Assert that code is running inside a traced call context — useful in utility functions that must only be invoked within an active Weave op.
python
```
import weave

weave.require_current_call()  # raises if no active call context
```
- ›Adds require_current_call function that raises an exception when the current call is None, enabling strict call-context assertions in instrumented code.
- ›Adds a setting to control code capture behavior in the Weave library.
- ›Table Creation and Update endpoints now return row digests, enabling callers to track and reference individual rows after writes.
- ›Adds pagination and sorting to object APIs, making large object collections navigable programmatically.
- ›Enables sorting and pagination on Table Query endpoints, supporting large-scale tabular data workflows.
+1 moreshow less
- ›Adds a chat view of calls in the UI, surfacing conversational LLM traces in a message-thread layout.
v0.51.7 Sep 16, 2024 · issue -374

Weave v0.51.7 adds post-processing hooks for call I/O, customizable display names, an Evaluation tab, and background image serialization.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.7 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.7
```
- ›Adds post-processing options for call inputs and outputs, enabling transformation or redaction of traced data at ingest time.
- ›Adds customizable display names for ops and calls via feat(weave): Add customizable display names.
- ›Adds a new Evaluation tab to the UI for browsing evaluation results.
- ›Makes Image serialization a background process, unblocking the main thread during large media uploads.
- ›Adds a refresh button to the Calls Table in the UI.
v0.51.6 Sep 12, 2024 · issue -374

Weave v0.51.6 adds native integration support for Mistral V1.0.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.6 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.6
```
- ›Adds integration support for Mistral V1.0, enabling automatic tracing of Mistral client calls.
v0.51.5 Sep 11, 2024 · issue -374

Weave v0.51.5 adds a Python API for LLM cost tracking and updates the Cohere v2 client integration.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.5 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.5
```
- ›Adds a Python API for querying and managing LLM costs (feat(weave): Add python api for costs).
- ›Updates the Cohere integration to support the Cohere Client v2 API.
v0.51.2 Sep 4, 2024 · issue -374

Weave v0.51.2 adds version-update alerts, image support in Eval Compare, and feedback data in calls stream queries.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.2 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.2
```
- ›Adds simple feedback response data to calls_stream_query, enabling retrieval of human feedback alongside call results.
- ›Alerts users in-library when a newer version of Weave is available.
- ›Adds image support in the Eval Compare view, allowing visual outputs to be compared across evaluation runs.
v0.51.0 Aug 29, 2024 · issue -375

Weave v0.51.0 adds server-side ref expansion and Python/curl export options for calls.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.51.0 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.0
```
- ›Adds Python and curl export options for calls, letting practitioners generate ready-to-run code from traced call data in the UI.
- ›Adds server-side ref expansion, resolving object references on the server rather than the client.
v0.50.15 Aug 27, 2024 · issue -375

Weave v0.50.15 adds Cerebras and Anthropic streaming integrations, PIL image support, call stream column selection, and evaluations page filtering.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.50.15 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.50.15
```
└──▷ USE IT
Trace a streaming Anthropic call end-to-end in a Weave-instrumented project.
python
```
import weave
import anthropic

weave.init('my-project')
client = anthropic.Anthropic()

with client.messages.stream(
    model='claude-3-opus-20240229',
    max_tokens=256,
    messages=[{'role': 'user', 'content': 'Summarize the water cycle.'}]
) as stream:
    for text in stream.text_stream:
        print(text, end='', flush=True)
```
Log a PIL image as a first-class Weave artifact inside a traced op.
python
```
import weave
from PIL import Image

weave.init('my-project')

@weave.op()
def process_image(path: str):
    img = Image.open(path)
    return img  # PIL Image is now serialized natively by Weave

process_image('screenshot.png')
```
- ›Adds invoke as a valid infer method for WeaveObject, expanding how model inference can be triggered.
- ›Adds simple column selection in call stream queries, letting callers retrieve only the fields they need.
- ›Adds first-class image support for PIL images, with a registered image serializer and type serializer in the manifest.
- ›Adds Anthropic Messages.stream support in the integration layer, enabling tracing of streaming Anthropic calls.
- ›Adds Cerebras as a supported integration.
+5 moreshow less
- ›Adds filtering and column management to the evaluations page UI.
- ›Adds a new filter UI across the application for improved trace and call filtering.
- ›Adds automatic renderer guessing for string values in the data table UI.
- ›Reference docs now include an interactive OpenAPI Spec viewer.
- ›Disallows cross-project reference lookups, scoping object references to their originating project.
└──▷ BREAKING ON UPGRADE
- !Cross-project reference lookups are no longer permitted; references are now scoped to their originating project and will fail if they point across project boundaries.
v0.50.14 Aug 13, 2024 · issue -375

Weave v0.50.14 adds object mutation support, data export (JSON/JSONL/CSV), configurable user settings, and feedback deletion in the UI.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.50.14 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.50.14
```
- ›Adds export of trace/call data to JSON, JSONL, CSV, or selected rows to CSV directly from the UI.
- ›Adds limited mutation support for Table and WeaveTable objects, enabling in-place updates to tracked datasets.
- ›Adds limited mutation support for other Weave objects (excluding WeaveTable) via the object mutations API.
- ›Adds configurable user settings via the new user settings feature in the Python API.
- ›Adds feedback deletion capability in the UI, allowing users to remove previously submitted feedback entries.
+4 moreshow less
- ›Models, Datasets, and Custom Objects now display object properties as columns when viewing all versions in the UI.
- ›Adds a new backend costs query API powering LLM token cost tracking, backed by an llm_token_prices table.
- ›Adds CMD-K keyboard shortcut for search within the Weave docs site.
- ›Overhauled Python API documentation with source links and improved Pydantic object rendering.
v0.50.12 Jul 25, 2024 · issue -376

Weave v0.50.12 adds HTTP debug logging via environment variable and automatic redaction of Authorization headers in traces.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.50.12 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.50.12
```
- ›Adds an environment variable to enable HTTP logging for debugging purposes.
v0.50.11 Jul 19, 2024 · issue -376

Weave v0.50.11 adds LangChain integration, CallsIter caching/slicing, threading helpers, and URL-persisted pagination state.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.50.11 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.50.11
```
- ›Adds caching and slicing support for CallsIter, enabling more efficient iteration over large call collections.
- ›Adds threading helpers via feat(weave) to simplify concurrent thread usage in Weave workflows.
- ›Adds LangChain integration, enabling tracing and evaluation of LangChain-based applications with Weave.
- ›Updated column management dialog improves control over visible columns in the trace table UI.
- ›Stores pagination state in the URL, so table pagination position is preserved and shareable across sessions.
v0.50.10 Jul 16, 2024 · issue -376

Weave v0.50.10 adds Cohere and Groq autopatch integrations, bulk deletion mode, and URL-persistent call grid sorting.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.50.10 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.50.10
```
- ›Adds autopatch integration with Groq, enabling automatic tracing of Groq chat calls.
- ›Adds Cohere chat models integration for automatic tracing of Cohere calls.
- ›Introduces bulk deletion mode in the UI for removing multiple calls at once.
- ›Stores the calls grid sort state in the URL, making sorted views shareable and persistent across sessions.
- ›Improves ergonomics for interacting with private Weave instances.
v0.50.8 Jul 11, 2024 · issue -376

Weave v0.50.8 adds DSPy integration, a new column management popup, and an updated OpenAI integration design pattern.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.50.8 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.50.8
```
- ›Adds new DSPy integration, enabling tracing and observability for DSPy-based LLM pipelines.
- ›Introduces a new column management popup in the UI for controlling visible columns in trace/eval tables.
- ›Updates the OpenAI integration to adhere to a new design pattern, aligning it with the broader integration architecture.
- ›Adds a rename button to the overflow menu for objects in the UI.
v0.50.7 Jul 11, 2024 · issue -376

Weave v0.50.7 adds a Use tab to call details and renders Anthropic input images as thumbnails in the UI.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.50.7 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.50.7
```
- ›Adds a 'Use' tab to call details for quick reference on how to access or replay a call.
- ›Renders Anthropic input images as thumbnails in the call detail view.
v0.50.6 Jul 8, 2024 · issue -376

Weave v0.50.6 adds call feedback UI, a new .call() method on ops, and promotes get_current_call to a top-level API.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.50.6 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.50.6
```
└──▷ USE IT
Retrieve the Call object from a decorated op to inspect call metadata (ID, inputs, outputs) without a separate lookup.
python
```
import weave

@weave.op()
def my_llm_call(prompt: str) -> str:
    return "response"

result, call = my_llm_call.call("What is the capital of France?")
print(call.id)
```
Inspect the currently executing call from inside any function in the call stack, useful for adding dynamic metadata mid-execution.
python
```
import weave

@weave.op()
def process(data: str) -> str:
    current = weave.get_current_call()
    print(current.id)
    return data
```
- ›Adds call function to decorated ops, returning a Call object alongside the op's result — accessible as my_op.call(...).
- ›Promotes get_current_call to a top-level API, making the active call inspectable from anywhere without internal imports.
- ›Adds a feedback tab to the call details page in the UI, surfacing notes and emoji reactions per call.
- ›Adds UI to attach notes and emoji reactions to individual calls.
- ›Adds basic call renaming in the UI.
+1 moreshow less
- ›New sidebar design in the web UI.
v0.50.4 Jun 17, 2024 · issue -377

Weave v0.50.4 adds Anthropic integration, feedback APIs, pluggable object serialization, call deletion, and LLM cost/token tracking.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.50.4 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.50.4
```
└──▷ USE IT
Automatically trace Anthropic API calls to capture inputs, outputs, and token usage in Weave.
python
```
import weave
import anthropic

weave.init('my-anthropic-project')

client = anthropic.Anthropic()
message = client.messages.create(
    model='claude-3-opus-20240229',
    max_tokens=1024,
    messages=[{'role': 'user', 'content': 'Hello, Claude!'}]
)
```
- ›Adds feedback Python API — create, read, and manage feedback on calls directly from the Weave Python client.
- ›Adds trace server feedback REST APIs for reading and writing structured feedback on trace calls.
- ›Adds attributes field to the Call object and support for setting an explicit root call via the updated Call interface.
- ›New Anthropic integration: automatic tracing of Anthropic API calls via the Weave integration layer.
- ›Adds pluggable object serialization, enabling custom serialization strategies for Weave objects.
+6 moreshow less
- ›Adds cost and token usage columns to the calls table and a cost summary tab in the trace tree UI.
- ›Enables deletion of individual calls — backend and frontend support for removing a single call from the trace store.
- ›Enables call renaming — backend support for updating the display name of an existing call.
- ›Adds a copyable call ID in the UI for quick reference and sharing of specific trace calls.
- ›Adds weave.finish function to explicitly finalize a Weave session.
- ›Supports double initialization (init) without raising an error, allowing weave.init to be called multiple times safely.

Weights & Biases Weave

Summary

What Weights & Biases Weave answers

Examples

Command line

Release history