Weights & Biases Weave — The AI Toolchain

Weights & Biases Weave v0.53.7

Thu, 27 Aug 2026 21:35:08 GMT

Weave v0.53.7 adds PII detection/redaction, an Agent PII policy field, and optional score-tracing control for imperative evals. • 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.

Weights & Biases Weave v0.53.6

Thu, 13 Aug 2026 22:41:03 GMT

Weave v0.53.6 adds Claude subagent tracing, private-IP remote scoring, parent-call span columns, and agent-span call linking. • 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. • Accepts JSON tool values in the TypeScript client, broadening tool input compatibility.

Weights & Biases Weave v0.53.6

Thu, 13 Aug 2026 22:41:03 GMT

Weave v0.53.6 adds Claude subagent tracing, private-IP remote scoring, parent-call span columns, and `record_error` for GenAI spans. • 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. • Records the agent span that invoked a call, enabling upstream attribution in trace trees.

Weights & Biases Weave v0.53.4

Fri, 31 Jul 2026 18:51:47 GMT

Weave v0.53.4 adds custom runtime registration APIs, Azure workload identity support, and expanded Claude Agent SDK tracing including image prompts. • 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.

Weights & Biases Weave v0.53.4

Fri, 31 Jul 2026 18:51:47 GMT

Weave v0.53.4 adds custom runtime registration API, Azure workload identity support, and Claude Agent SDK image prompt tracing. • 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.

Weights & Biases Weave v0.53.3

Fri, 31 Jul 2026 18:51:26 GMT

Weave v0.53.3 adds agent dashboard persistence, eval linking, feedback totals, agent event emission, and `reasoning_effort` on the completions API. • 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. • Separates turn input and output messages in the TypeScript SDK for finer-grained conversation tracing.

Weights & Biases Weave v0.53.3

Fri, 31 Jul 2026 18:51:26 GMT

Weave v0.53.3 adds reasoning_effort to completions API, agent event emission, persisted agent dashboards, and feedback query totals. • 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. • Separates turn input and output messages in TypeScript tracing for clearer multi-turn conversation structure.

Weights & Biases Weave v0.53.2

Thu, 16 Jul 2026 23:38:10 GMT

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. • 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. • 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).

Weights & Biases Weave v0.53.1

Thu, 02 Jul 2026 21:15:53 GMT

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. • Adds `userMessage` and `systemInstructions` parameters when creating `Turn`s in the TypeScript API. • Adds `agent_id`, `agent_description`, and `agent_version` parameters when creating `Turn`s in the TypeScript API. • Adds `agent_id`, `agent_description`, and `agent_version` parameters when creating `Conversation`s in the TypeScript API. • Adds `systemInstructions` parameter when creating `Subagents` in the TypeScript API. • Adds `systemInstructions` parameter when creating `LLM`s in the TypeScript API. • 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.

Weights & Biases Weave v0.53.0

Thu, 02 Jul 2026 21:12:55 GMT

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. • 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. • 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 changes: • 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.

Weights & Biases Weave v0.52.43

Mon, 15 Jun 2026 21:31:45 GMT

Weave v0.52.43 adds OpenAI Agents SDK span emission, aggregate feedback endpoint, `set_attributes`/`add_event` on span types, and playground trace routing. • 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). • 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.

Weights & Biases Weave v0.52.42

Tue, 02 Jun 2026 03:31:19 GMT

Weave v0.52.42 adds Google ADK and Claude Agents OTEL integrations, annotation queue SDK helpers, rescore support, and richer token tracking. • 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. • 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.

Weights & Biases Weave v0.52.41

Thu, 28 May 2026 23:30:10 GMT

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. • 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.

Weights & Biases Weave v0.52.40

Thu, 14 May 2026 03:49:20 GMT

Weave v0.52.40 adds agent span ref kinds, feedback folding via `include_feedback`, dynamic JSON filter cast inference, and agent numeric stats buckets. • 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. • Reduces per-op overhead in async tracing for lower-latency instrumentation.

Weights & Biases Weave v0.52.39

Mon, 11 May 2026 22:10:57 GMT

Weave v0.52.39 adds a GenAI observability schema with OTel span emission, agent-scoring events, and Session SDK ergonomics for manually-instrumented agents. • 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. • 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.

Weights & Biases Weave v0.52.38

Tue, 05 May 2026 04:05:37 GMT

Weave v0.52.38 adds GEPA integration, Session SDK, prompt registry linking, server-side eval pagination, and agent observability. • 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. • 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.

Weights & Biases Weave v0.52.37

Fri, 17 Apr 2026 17:54:14 GMT

Weave v0.52.37 adds cached-token cost tracking, OTel convention updates, and Node SDK prompt-registry linking. • 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.

Weights & Biases Weave v0.52.36

Wed, 01 Apr 2026 17:25:13 GMT

Weave v0.52.36 adds username resolution on calls, text-based eval results, and lazy ref resolution without explicit client init. • 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`.

Weights & Biases Weave v0.52.35

Thu, 19 Mar 2026 20:13:08 GMT

Weave v0.52.35 adds WAL mechanics, feedback stats queries, wildcard ref filtering, and a Redis client configuration. • 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(). • Adds client-side digest calculation plumbing to reduce server-side load.

Weights & Biases Weave v0.52.33

Thu, 12 Mar 2026 00:26:21 GMT

Weave v0.52.33 adds automatic instrumentation for the OpenAI Agents Realtime API and new SDK/HTTP support for tags and aliases. • 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.

Weights & Biases Weave v0.52.32

Thu, 12 Mar 2026 00:01:50 GMT

Weave v0.52.32 adds SDK client methods and HTTP bindings for tags/aliases, plus initial OpenAI Agents Realtime API support. • Adds SDK client methods and HTTP bindings for tags and aliases management. • Adds initial support for the OpenAI Agents Realtime API.

Weights & Biases Weave v0.52.31

Tue, 10 Mar 2026 03:42:12 GMT

Weave v0.52.31 adds Claude agents integration, Fireworks provider support, trace server backend for tags and aliases, and timestamps/TTFT for realtime tracing. • 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.

Weights & Biases Weave v0.52.30

Tue, 10 Mar 2026 03:41:09 GMT

Weave v0.52.30 adds a score-backfill endpoint, Gemini tracking in the TS SDK, and sharded distributed calls for better query performance. • 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.

Weights & Biases Weave v0.52.29

Fri, 27 Feb 2026 00:55:17 GMT

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. • 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. • Adds API for editing annotation queue metadata. • Adds claude-sonnet 4.6 to the supported model providers list.

Weights & Biases Weave v0.52.28

Sat, 14 Feb 2026 21:07:25 GMT

Weave v0.52.28 adds OpenAI Realtime GA support, $lt/$lte ORM filters, and resource attributes for W&B vars via OTel. • 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. • Adds Vertex AI as a supported LLM provider.

Weights & Biases Weave v0.52.26

Tue, 03 Feb 2026 18:54:52 GMT

Weave v0.52.26 adds usage stats APIs, a performance flag, Anthropic parse patching, and column ordering for saved views. • 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). • Adds support for filtering calls by annotation queue. • Allows LLM-as-a-Judge evaluations to specify image and video scoring targets.

Weights & Biases Weave v0.52.24

Thu, 15 Jan 2026 20:51:13 GMT

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. • 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. • Adds a helper method for TypeScript SDK prompt management.

Weights & Biases Weave v0.52.23

Thu, 08 Jan 2026 18:23:16 GMT

Weave v0.52.23 adds logfire/pydantic-ai parsing, annotation queue APIs, and broader LangChain autopatching. • 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. • Exposes storage parameters in weave_client.get_calls().

Weights & Biases Weave v0.52.22

Thu, 08 Jan 2026 18:13:30 GMT

Weave v0.52.22 adds prompt and template variable persistence on LLMStructuredCompletionModels. • 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.

Weights & Biases Weave v0.52.20

Wed, 26 Nov 2025 22:45:10 GMT

Weave v0.52.20 adds Bedrock Agents tracing, TypeScript `withAttributes`, OpenAI x-request-id tracking, prompt vars in streaming completions, and `ObjectRef.fromUri`. • 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 changes: • Minimum Python version raised to 3.10; setups running Python 3.8 or 3.9 will break on upgrade.

Weights & Biases Weave v0.52.16

Fri, 07 Nov 2025 19:49:48 GMT

Weave v0.52.16 adds dataclass redaction support and lets users associate traces with a specific W&B Run. • 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.

Weights & Biases Weave v0.52.15

Thu, 06 Nov 2025 20:19:57 GMT

Weave v0.52.15 adds batch object creation and OTEL span op generation. • 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.

Weights & Biases Weave v0.52.14

Fri, 31 Oct 2025 20:41:36 GMT

Weave v0.52.14 adds imperative call logging, new CRUD endpoints for Models/EvaluationRuns/Predictions/Scores, and OTEL wb_run_id attribution. • 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. • Supports properly retrieving a dataset in the TypeScript SDK.

Weights & Biases Weave v0.52.11

Thu, 23 Oct 2025 01:49:07 GMT

Weave v0.52.11 adds CRUD endpoints for Ops, Datasets, Scorers, and Evaluations, plus incremental score aggregation and a fire-and-forget EvaluationLogger API. • 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. • 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.

Weights & Biases Weave v0.52.9

Fri, 10 Oct 2025 17:25:42 GMT

Weave v0.52.9 adds OpenAI Realtime support, image tracing, OTEL user ID parsing, custom call-page content, and a new object query filter. • 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.

Weights & Biases Weave v0.52.8

Wed, 17 Sep 2025 15:18:16 GMT

Weave v0.52.8 adds `from_data_url`, JSON serialization, and URL-based loading for the Content type. • 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.

Weights & Biases Weave v0.52.7

Fri, 12 Sep 2025 11:21:08 GMT

Weave v0.52.7 adds implicit patching, verifier integration, object deletion API, and a new GLM-4.5 model. • 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 changes: • Removes Pydantic v1 support; setups relying on Pydantic v1 will break on upgrade.

Weights & Biases Weave v0.52.5

Thu, 28 Aug 2025 23:21:33 GMT

Weave v0.52.5 adds user-controlled key redaction, a wandb integration, and parallel table uploads for faster tracing. • 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.

Weights & Biases Weave v0.52.4

Sat, 23 Aug 2025 00:57:24 GMT

Weave v0.52.4 adds time-to-first-token for OpenAI streaming, improved DSPy integration, parallel scorer execution, and DeepSeek v3 cost tracking. • 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.

Weights & Biases Weave v0.52.1

Tue, 19 Aug 2025 13:43:54 GMT

Weave v0.52.1 adds OTEL thread parsing, custom eval attributes, OpenAI inference in the playground, and GPT-5/Claude 4.1 cost support. • 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. • 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 changes: • Removes support for the `google-generativeai` package integration; users must migrate to the `google-genai` (google-genai) integration.

Weights & Biases Weave v0.51.59

Fri, 25 Jul 2025 22:09:25 GMT

Weave v0.51.59 adds Thread API filtering, generic content support, document views for LangChain/ChromaDB, and a major call-filter performance boost. • 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. • 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.

Weights & Biases Weave v0.51.56

Thu, 10 Jul 2025 22:18:28 GMT

Weave v0.51.56 adds saved views for the Threads page and customizable chart names in the trace table. • 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.

Weights & Biases Weave v0.51.55

Wed, 09 Jul 2025 20:23:58 GMT

Weave v0.51.55 adds HuggingFace Datasets integration, online evals, JSON Schema in Playground, LangChain ChatView, and a new thread_id column. • 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. • 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.

Weights & Biases Weave v0.51.54

Mon, 16 Jun 2025 21:59:34 GMT

Weave v0.51.54 adds OpenAI Responses API tracing, a Chat View for Responses, and online LLM-as-a-judge evals. • 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.

Weights & Biases Weave v0.51.52

Wed, 11 Jun 2025 02:41:29 GMT

Weave v0.51.52 adds end-to-end online monitoring, Anthropic SDK support, OpenAI API endpoint tracking, and an updated LLMStructuredCompletionModel. • 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.

Weights & Biases Weave v0.51.48

Fri, 23 May 2025 19:09:21 GMT

Weave v0.51.48 adds smolagents integration, OTEL chat view, evaluation comparison reports, and a `WEAVE_LOG_LEVEL` setting. • 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. • TypeScript SDK: call handles can now be returned from traced functions.

Weights & Biases Weave v0.51.47

Thu, 15 May 2025 22:01:06 GMT

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. • 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. • Shows object storage size on the project overview page.

Weights & Biases Weave v0.51.46

Fri, 09 May 2025 20:51:09 GMT

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. • 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. • Adds a drawer to the providers tab in the UI.

Weights & Biases Weave v0.51.45

Wed, 07 May 2025 17:05:41 GMT

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. • 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. • 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.

Weights & Biases Weave v0.51.44

Thu, 24 Apr 2025 19:59:58 GMT

Weave v0.51.44 adds a `Monitor` SDK class for online monitoring, imperative eval improvements, and storage-size visibility in object details. • 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. • Enables editing of list-valued dataset cells in the UI. • Includes notes and reactions when adding calls to datasets.

Weights & Biases Weave v0.51.43

Fri, 18 Apr 2025 04:25:56 GMT

Weave v0.51.43 adds imperative evaluation APIs, MCP python-sdk support, OTEL/OpenInference semantic conventions, and promotes Playground to GA. • 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. • 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.

Weights & Biases Weave v0.51.42

Tue, 08 Apr 2025 18:16:11 GMT

Weave v0.51.42 adds AWS Bedrock Guardrails scoring and OpenTelemetry tracing support. • 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.

Weights & Biases Weave v0.51.41

Thu, 03 Apr 2025 02:06:14 GMT

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. • 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. • 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.

Weights & Biases Weave v0.51.39

Mon, 24 Mar 2025 20:56:12 GMT

Weave v0.51.39 adds a CrewAI integration and inline serializers for custom type handling. • 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.

Weights & Biases Weave v0.51.38

Fri, 21 Mar 2025 21:41:00 GMT

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. • 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. • Improves WebP image support in trace views. • Adds a Providers overview page to the UI.

Weights & Biases Weave v0.51.37

Mon, 17 Mar 2025 20:45:02 GMT

Weave v0.51.37 adds CSV dataset upload support in the UI. • Adds the ability to upload a dataset directly from a CSV file via the UI.

Weights & Biases Weave v0.51.36

Thu, 06 Mar 2025 01:06:12 GMT

Weave v0.51.36 adds non-SaaS BYOB support, `client.finish`, user-configurable retry settings, and gpt-4.5-preview/deepseek in the playground. • 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.

Weights & Biases Weave v0.51.35

Tue, 25 Feb 2025 19:33:41 GMT

Weave v0.51.35 adds pandas export for calls, dataset ingestion from calls in the UI, and Pydantic subclass JSON support. • 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.

Weights & Biases Weave v0.51.34

Thu, 20 Feb 2025 21:52:02 GMT

Weave v0.51.34 adds HuggingFace inference integration, new LLM scorers, PII redaction via Presidio, and global attributes on init. • 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. • 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.

Weights & Biases Weave v0.51.33

Wed, 05 Feb 2025 19:49:12 GMT

Weave v0.51.33 adds prompt injection detection guardrails, a disk cache for server functions, and a Scorer logs viewer. • 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. • Adds a basic viewer for a Scorer's logs in the UI. • Adds a lightbox for images in the UI.

Weights & Biases Weave v0.51.32

Wed, 29 Jan 2025 22:04:49 GMT

Weave v0.51.32 adds artifact ref links in the UI, predefined keyboard bindings, and the ability to disable context capture. • 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).

Weights & Biases Weave v0.51.31

Fri, 24 Jan 2025 16:43:47 GMT

Weave v0.51.31 adds Dataset construction from Calls, pandas bridging helpers, and an in-UI dataset editing interface. • 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.

Weights & Biases Weave v0.51.30

Wed, 22 Jan 2025 18:43:51 GMT

Weave v0.51.30 adds autopatch opt-out support and a configurable grid page size in the UI. • 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.

Weights & Biases Weave v0.51.29

Fri, 17 Jan 2025 18:56:19 GMT

Weave v0.51.29 adds Bedrock integration, JPEG/PNG tracking, SDK object deletion, and improved ref-getting. • 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. • Non-admin users can now delete objects through the UI object deletion interface.

Weights & Biases Weave v0.51.28

Tue, 14 Jan 2025 16:39:19 GMT

Weave v0.51.28 adds code redaction, global post-processing options, UI object deletion, and guardrails/monitoring via scorer application. • 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. • 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.

Weights & Biases Weave v0.51.27

Fri, 03 Jan 2025 22:00:55 GMT

Weave v0.51.27 adds op configuration for autopatched integrations and ChatNVIDIA autopatch support in LangChain. • 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.

Weights & Biases Weave v0.51.25

Tue, 17 Dec 2024 19:09:56 GMT

Weave v0.51.25 adds op-level trace sampling, OpenAI moderation/embeddings tracking, and op configuration for autopatched functions. • 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.

Weights & Biases Weave v0.51.24

Wed, 11 Dec 2024 21:38:10 GMT

Weave v0.51.24 adds named evals, AzureOpenAI scorer support, op code capture, and Anthropic Chat View support. • 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.

Weights & Biases Weave v0.51.23

Tue, 03 Dec 2024 22:01:11 GMT

Weave v0.51.23 adds VertexAI and Google GenAI integrations, Bedrock LLMs in Playground, and a new Scorers section in the side nav. • 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. • Adds an explicit object preparation hook for types that require custom serialization (e.g. `PIL.Image.Image`).

Weights & Biases Weave v0.51.22

Thu, 21 Nov 2024 20:22:08 GMT

Weave v0.51.22 adds object comparison in the UI and introduces simple prompt classes. • Adds simple prompt classes for structured prompt management. • Adds object comparison view in the UI for side-by-side inspection of Weave objects.

Weights & Biases Weave v0.51.20

Tue, 19 Nov 2024 23:34:42 GMT

Weave v0.51.20 adds Dataset iteration, OpenAI beta parse API tracking, up/down call navigation, and a number-parsing string op. • 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. • 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.

Weights & Biases Weave v0.51.19

Mon, 04 Nov 2024 21:34:44 GMT

Weave v0.51.19 adds project-level leaderboards, single-call retrieval from the TS client, and dict serialization of inputs/outputs. • 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.

Weights & Biases Weave v0.51.18

Fri, 01 Nov 2024 01:58:27 GMT

Weave v0.51.18 adds an initial scorer suite, a JS SDK, a completions endpoint, leaderboard support, and trace page charts. • 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. • 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.

Weights & Biases Weave v0.51.17

Thu, 17 Oct 2024 22:13:53 GMT

Weave v0.51.17 adds NotDiamond integration, paginated table queries, `display_name` for ops, a finish handler for ops, and a `Callout` UI component. • 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. • Adds a new `Callout` UI component to the frontend component library. • Improves table query performance by splitting metadata and value retrieval in object queries.

Weights & Biases Weave v0.51.16

Wed, 16 Oct 2024 19:16:46 GMT

Weave v0.51.16 adds NotDiamond integration, paginated table queries, op display names, finish handlers, and async-friendly tracing. • 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. • New `Callout` UI component available in the frontend component library.

Weights & Biases Weave v0.51.14

Wed, 09 Oct 2024 19:17:10 GMT

Weave v0.51.14 adds paginated table queries, TableQueryStats exposure, minimized blocking during tracing, and a finish handler for ops. • 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.

Weights & Biases Weave v0.51.12

Mon, 30 Sep 2024 23:28:47 GMT

Weave v0.51.12 adds optional feedback inclusion in calls export. • Adds the ability to optionally include feedback data in calls export.

Weights & Biases Weave v0.51.10

Thu, 26 Sep 2024 19:59:04 GMT

Weave v0.51.10 adds an Instructor integration for structured output tracing. • Adds an Instructor integration, enabling tracing of structured LLM outputs produced via the Instructor library.

Weights & Biases Weave v0.51.8

Fri, 20 Sep 2024 16:04:07 GMT

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. • 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. • Adds a chat view of calls in the UI, surfacing conversational LLM traces in a message-thread layout.

Weights & Biases Weave v0.51.7

Mon, 16 Sep 2024 22:56:15 GMT

Weave v0.51.7 adds post-processing hooks for call I/O, customizable display names, an Evaluation tab, and background image serialization. • 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.

Weights & Biases Weave v0.51.6

Thu, 12 Sep 2024 18:35:11 GMT

Weave v0.51.6 adds native integration support for Mistral V1.0. • Adds integration support for Mistral V1.0, enabling automatic tracing of Mistral client calls.

Weights & Biases Weave v0.51.5

Wed, 11 Sep 2024 19:59:07 GMT

Weave v0.51.5 adds a Python API for LLM cost tracking and updates the Cohere v2 client integration. • 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.

Weights & Biases Weave v0.51.2

Wed, 04 Sep 2024 16:35:17 GMT

Weave v0.51.2 adds version-update alerts, image support in Eval Compare, and feedback data in calls stream queries. • 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.

Weights & Biases Weave v0.51.0

Thu, 29 Aug 2024 02:41:03 GMT

Weave v0.51.0 adds server-side ref expansion and Python/curl export options for calls. • 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.

Weights & Biases Weave v0.50.15

Tue, 27 Aug 2024 17:32:23 GMT

Weave v0.50.15 adds Cerebras and Anthropic streaming integrations, PIL image support, call stream column selection, and evaluations page filtering. • 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. • 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 changes: • 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.

Weights & Biases Weave v0.50.14

Tue, 13 Aug 2024 00:15:02 GMT

Weave v0.50.14 adds object mutation support, data export (JSON/JSONL/CSV), configurable user settings, and feedback deletion in the UI. • 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. • 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.

Weights & Biases Weave v0.50.12

Thu, 25 Jul 2024 23:35:41 GMT

Weave v0.50.12 adds HTTP debug logging via environment variable and automatic redaction of Authorization headers in traces. • Adds an environment variable to enable HTTP logging for debugging purposes.

Weights & Biases Weave v0.50.11

Fri, 19 Jul 2024 23:05:43 GMT

Weave v0.50.11 adds LangChain integration, CallsIter caching/slicing, threading helpers, and URL-persisted pagination state. • 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.

Weights & Biases Weave v0.50.10

Tue, 16 Jul 2024 21:31:44 GMT

Weave v0.50.10 adds Cohere and Groq autopatch integrations, bulk deletion mode, and URL-persistent call grid sorting. • 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.

Weights & Biases Weave v0.50.8

Thu, 11 Jul 2024 16:13:57 GMT

Weave v0.50.8 adds DSPy integration, a new column management popup, and an updated OpenAI integration design pattern. • 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.

Weights & Biases Weave v0.50.7

Thu, 11 Jul 2024 16:12:46 GMT

Weave v0.50.7 adds a Use tab to call details and renders Anthropic input images as thumbnails in the UI. • 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.

Weights & Biases Weave v0.50.6

Mon, 08 Jul 2024 20:02:23 GMT

Weave v0.50.6 adds call feedback UI, a new .call() method on ops, and promotes `get_current_call` to a top-level API. • 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. • New sidebar design in the web UI.

Weights & Biases Weave v0.50.4

Mon, 17 Jun 2024 18:44:32 GMT

Weave v0.50.4 adds Anthropic integration, feedback APIs, pluggable object serialization, call deletion, and LLM cost/token tracking. • 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. • 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.