DSPy — The AI Toolchain

DSPy 3.3.1

Fri, 21 Aug 2026 23:07:09 GMT

DSPy 3.3.1 adds managed Deno runtime for PythonInterpreter, multi-proposal GEPA optimization, structured MCP results, and expanded callback lifecycle visibility. • Adds `pip install 'dspy[deno]'` optional extra to provide a managed Deno 2.x runtime for `PythonInterpreter`, pinning Pyodide and validating Deno `>=2.0.0,<3.0.0` without requiring a system install. • Adds `result_mode='structured'` parameter to dspy.Tool.from_mcp_tool(), returning `structuredContent` from MCP SDK v2 servers (including arrays, scalars, empty values, and explicit JSON `null`) with fallback to existing content conversion. • Supports GEPA 0.1.4's multi-proposal contracts via `gepa_kwargs`, accepting keys `sampling_strategy`, `selection_strategy`, and `acceptance_criterion` to enable concurrent candidate evaluation within the existing `num_threads` budget. • Adds objective-aware frontier tracking in GEPA via `gepa_kwargs`, supporting `objective_scores` dimensions (quality, privacy, cost) for parent/merge selection while the scalar metric continues to gate acceptance. • Exposes full `PythonInterpreter` lifecycle events through DSPy's callback API: interpreter execution start/end, sandbox-to-host tool-call start/end, and interpreter process startup/shutdown — with callback ancestry retained across modules. • Adds `PythonInterpreter.execution_instructions` to give RLM an accurate description of the Pyodide environment, including state persistence and unavailable native process capabilities. • Extends optimizer compile() runs with start/end callback coverage, consistent with the interpreter lifecycle events. • Adds `timeout` parameter to Image.from_url() and Audio.from_url(), defaulting to 30 seconds; pass `timeout=None` to restore the previous unbounded behavior. • Supports MCP SDK v2 field names, v1 `ClientSession`, and v2 high-level `Client` in DSPy's MCP bridge, without changing default tool-result semantics. • XMLAdapter now formats and parses nested Pydantic models, typed dictionaries, lists, mappings, nullable fields, and unions as nested XML, while remaining backward-compatible with the previous JSON-inside-XML representation. • `CodeInterpreterError` is now also a `DSPyError` subclass while retaining `RuntimeError` compatibility, enabling unified catch blocks across interpreter and agent modules. • `max_reflection_cost` in DSPy's GEPA adapter now raises clearly when set instead of silently providing an ineffective budget. • Strengthens `PythonInterpreter` sandbox isolation: request IDs are unpredictable, recursive execution through host tools is rejected, Deno-cache access is revoked after startup, and guest code cannot mutate JavaScript globals or prototypes to change host-tool identity. Breaking changes: • `dspy.CodeAct` and `dspy.ProgramOfThought` now emit `DeprecationWarning` on construction and are scheduled for removal in DSPy 3.5; migrate to `dspy.RLM`. • Image.from_url() and Audio.from_url() now default to a 30-second timeout instead of waiting indefinitely; code relying on unbounded download time must pass `timeout=None` explicitly.

DSPy 3.3.0

Mon, 03 Aug 2026 20:06:03 GMT

DSPy 3.3.0 adds Flex structure-optimizing programs, ReActV2 with native tool calling, and a typed provider-neutral LM boundary. • Adds `dspy.Flex`, an experimental module that places program structure — predictors, control flow, DSPy primitives, and Python/LM balance — into the GEPA search space so the optimizer discovers decomposition instead of only tuning prompts; defaults to a single `dspy.Predict` baseline, or `dspy.RLM` when tools are supplied. • Adds `max_predictor_calls` guard on Flex-generated programs to prevent runaway LM usage in optimizer-authored code, and supports a `program_trace` argument to metrics so programs can be scored on how a result was produced (e.g. penalizing excessive LM calls). • Persists optimizer-discovered `module_src` as part of a Flex program's serialized state, so dump_state() / load_state() round-trips preserve the GEPA-authored implementation. • Adds `dspy.ReActV2`, an experimental ReAct implementation built on native tool calling, using `dspy.History`, `dspy.Tool`, and `dspy.ToolCalls` (which can optionally store `dspy.ToolCallResults`) instead of custom `next_tool_args` / `trajectory` syntax. • Adds `parallel_tool_calls` support to `dspy.ReActV2`, preserving each call/result pair by ID in both native and non-native mode. • Adds multi-turn native tool call support to `dspy.ReActV2`: prior tool calls and results are replayed as structured assistant and tool messages rather than being flattened into prompt text, enabling prompt-caching reuse of stable prefixes (observed up to 50% cost reduction in internal testing). • Introduces a typed, provider-neutral LM contract — `def forward(self, request: dspy.LMRequest) -> dspy.LMResponse` — that custom LM authors can implement instead of guessing at OpenAI/LiteLLM-shaped inputs; opt in with dspy.context(experimental=True). • Exports the typed LM API (`dspy.LMRequest`, `dspy.LMResponse`, `dspy.LMToolCallPart`) and supports typed direct calls through `BaseLM.__call__`. • Adds `dspy.LMError` (and narrower DSPy subclasses) as a provider-neutral exception type, replacing the need to catch provider-specific exception classes. • Adds BaseLM.dump_state() and BaseLM.load_state() for sanitized LM state serialization that excludes API keys, preserves legacy saved states, and requires explicit opt-in before importing trusted custom LM classes. • Makes LiteLLM imports lazy, decoupling the core LM API from a specific provider bridge at import time. • Makes optional-provider imports thread-safe. • Adds explicit factory methods Image.from_path(), Image.from_url(), Audio.from_path(), Audio.from_url(), File.from_path() as the new required API for resource loading, replacing implicit I/O on construction. • OpenAI Responses API path now emits Responses-native tool and `tool_choice` request shapes, with legacy Responses outputs using the same Chat-style tool-call representation as the Chat Completions path. • Makes `numpy` an optional install extra (`pip install 'dspy[numpy]'`), reducing the base install footprint; affected features include embeddings, KNN/KNNFewShot, SIMBA, and other NumPy-backed optimizer or retrieval paths. • Updates `DspyGEPAResult` to mirror `gepa[dspy]==0.1.1` result shapes, making `candidates` and `best_candidate` return compiled DSPy modules; `val_subscores`, `per_val_instance_best_candidates`, `best_outputs_valset`, and `highest_score_achieved_per_val_task` all have updated types keyed by validation instance id. • Replaces `reflection_prompt_template` in `dspy.GEPA` `gepa_kwargs` with an `instruction_proposer` parameter for custom proposal behavior (passing `reflection_prompt_template` now raises a clear `ValueError`). Breaking changes: • Constructing `dspy.Image`, `dspy.Audio`, or `dspy.File` from a path or URL no longer reads or fetches the resource implicitly; use Image.from_path(), Image.from_url(), Audio.from_path(), Audio.from_url(), or File.from_path() instead. • Image.from_url(..., download=...) and the `download_images` / `verify` options on encode_image() were removed; use an explicit factory or reference constructor instead. • encode_image(path), encode_audio(path_or_url), and encode_file_to_dict(path) are replaced by Image.from_path(), Audio.from_path() / Audio.from_url(), and File.from_path() respectively. • Image.from_file(), Image.from_PIL(), and Audio.from_file() are deprecated aliases scheduled for removal in 3.4; use Image.from_path(), Image(pil_image), and Audio.from_path() respectively. • `numpy` is no longer installed with base `dspy`; code using embeddings, KNN/KNNFewShot, SIMBA, or other NumPy-backed paths will break unless `pip install 'dspy[numpy]'` is added. • `DspyGEPAResult.candidates` now returns a list of compiled DSPy modules instead of instruction dictionaries, and `DspyGEPAResult.best_candidate` now returns a compiled DSPy module; code inspecting `optimized_program.detailed_results` must be updated. • `DspyGEPAResult` fields `val_subscores`, `per_val_instance_best_candidates`, `best_outputs_valset`, and `highest_score_achieved_per_val_task` have new types keyed by validation instance id. • GEPA 0.1.1 renamed default reflection template placeholders from `` / `` to `` / ``; custom templates using the old names must be updated. • Passing `reflection_prompt_template` through `gepa_kwargs` in `dspy.GEPA` now raises a `ValueError`; use `instruction_proposer` instead. • `RLM.max_iterations` is renamed to `RLM.max_iters`; code constructing dspy.RLM(max_iterations=...) will break.

DSPy 3.3.0

Mon, 03 Aug 2026 20:06:03 GMT

DSPy 3.3.0 adds Flex structure optimization, ReActV2 with native tool-calling, and a typed provider-neutral LM boundary. • Adds `dspy.Flex`, an experimental module that places program structure itself into the GEPA optimization search space, starting from a single `dspy.Predict` (or `dspy.RLM` when tools are supplied) and rewriting control flow, DSPy primitives, and the balance between Python and LM calls against a user metric; the discovered implementation is stored in `optimized.module_src` and preserved through save/load. • Adds `max_predictor_calls` guard to `dspy.Flex`-generated programs to prevent runaway LM usage in optimizer-authored code, and allows metrics to accept a `program_trace` argument to score how a result was produced. • Adds `dspy.ReActV2`, an experimental ReAct implementation built on native tool calling that uses `dspy.History`, `dspy.Tool`, and `dspy.ToolCalls` (optionally storing `dspy.ToolCallResults`) instead of the custom `next_tool_args` / trajectory syntax. • Adds `parallel_tool_calls` support in `dspy.ReActV2`, preserving each call/result pair by ID in both native and non-native mode. • Adds multi-turn native tool call support in `dspy.ReActV2`: prior tool calls and results are replayed as structured assistant and tool messages rather than flattened prompt text, enabling prompt-cache reuse and observed up to 50% cost reductions. • Introduces a typed, provider-neutral LM boundary via `dspy.LMRequest` / `dspy.LMResponse` and a `BaseLM.forward(request: dspy.LMRequest) -> dspy.LMResponse` contract; opt in with dspy.context(experimental=True). • Adds BaseLM.dump_state() and BaseLM.load_state() for sanitized LM-state serialization that strips API keys and preserves legacy saved states. • Adds `dspy.LMError` (and narrower DSPy subclasses) so callers can catch LM errors without depending on provider-specific exception classes. • Makes LiteLLM imports lazy, decoupling the core LM API from the LiteLLM provider bridge at import time. • Adds explicit Image.from_path(path), Image.from_url(url), Audio.from_path(path), Audio.from_url(url), File.from_path(path) factory methods that make I/O intent explicit, replacing implicit path/URL interpretation in constructors. • The OpenAI Responses API path now emits Responses-native tool and `tool_choice` request shapes, and typed `LMToolCallPart` objects preserve raw provider fields. • Makes `numpy` an optional extra (`pip install 'dspy[numpy]'`), keeping the base install lighter; required for embeddings, KNN/KNNFewShot, SIMBA, and other NumPy-backed optimizer or retrieval paths. • Updates `DspyGEPAResult` to mirror the `gepa[dspy]==0.1.1` API: `candidates` and `best_candidate` are now compiled DSPy modules, `val_subscores` is `list[dict[Any, float]]` keyed by validation instance id, and `best_outputs_valset` is `dict[Any, list[tuple[int, Prediction]]]`. • Adds a `ValueError` when `reflection_prompt_template` is passed via `gepa_kwargs` to `dspy.GEPA`, directing users to the `instruction_proposer` parameter for custom proposal behavior. • Adds RLM namespace validation that fails at construction time for duplicate tool names, Python-keyword tool names, and signature inputs that collide with built-in sandbox functions. Breaking changes: • Constructing `dspy.Image`, `dspy.Audio`, or `dspy.File` from a path or URL string no longer performs implicit I/O; use Image.from_path(), Image.from_url(), Audio.from_path(), Audio.from_url(), or File.from_path() instead. • Image.from_url() now downloads and returns an embedded data URI; use Image(url) when the provider should fetch the URL reference without downloading. • Image.from_url(..., download=...) and the `download_images` / `verify` options on encode_image() are removed. • encode_image(path), encode_audio(path_or_url), and encode_file_to_dict(path) are replaced by Image.from_path(), Audio.from_path() / Audio.from_url(), and File.from_path() respectively. • Image.from_file(), Image.from_PIL(), and Audio.from_file() are deprecated aliases scheduled for removal in 3.4; use Image.from_path(), Image(pil_image), and Audio.from_path() instead. • `numpy` is no longer installed with base `dspy`; install `pip install 'dspy[numpy]'` to restore embeddings, KNN/KNNFewShot, SIMBA, and other NumPy-backed paths. • `DspyGEPAResult.candidates` is now a list of compiled DSPy modules (not instruction dictionaries), `DspyGEPAResult.best_candidate` is a compiled DSPy module, `val_subscores` is `list[dict[Any, float]]`, `per_val_instance_best_candidates` is `dict[Any, set[int]]`, `best_outputs_valset` is `dict[Any, list[tuple[int, Prediction]]]`, and `highest_score_achieved_per_val_task` is keyed by validation instance id. • GEPA 0.1.1 renamed reflection template placeholders from `` / `` to `` / ``; custom templates using the old names must be updated. • `RLM.max_iterations` is renamed to `RLM.max_iters`; code passing `max_iterations=` to the RLM constructor must be updated. • RLM construction now raises an error for duplicate tool names, Python-keyword tool names, or signature inputs that collide with built-in sandbox functions.

DSPy 3.2.0

Tue, 21 Apr 2026 17:17:03 GMT

DSPy 3.2.0 chains optimizers in BetterTogether, decouples from LiteLLM, and adds type-mismatch warnings and safe cache deserialization. • Adds dspy.configure(warn_on_type_mismatch=False) to control new type-validation warnings that fire when a value passed to a signature field doesn't match its declared type (powered by `typeguard`); extra fields not in the signature also warn. • Adds dspy.configure_cache(restrict_pickle=True) to swap `pickle.load` with a restricted unpickler that only allows litellm/openai types, numpy reconstruction helpers, and user-registered `safe_types`, preventing arbitrary code execution from malicious cache files. • Adds `verify` parameter to `Image` for SSL bypass. • Adds `EmbeddingsWithScores` retriever for direct access to similarity scores alongside retrieval results. • Adds `XMLAdapter` to DSPy. • Adds file output support to `inspect_history`. • `BetterTogether` now accepts arbitrary optimizers as keyword arguments and chains them via `strategy` strings (e.g., BetterTogether(metric=m, p=GEPA(...), w=BootstrapFinetune(...)) with `strategy='p -> w -> p'`), evaluating each step on a valset and returning the best program. • `BaseLM` now exposes capability properties (`supports_function_calling`, `supports_reasoning`, `supports_response_schema`, `supported_params`) so custom backends integrate with DSPy's retry/truncation logic without any `litellm` dependency; `dspy.ContextWindowExceededError` replaces the `litellm` error throughout. • `optuna` is now an optional dependency installable via `pip install dspy[optuna]`; only `MIPROv2` and `BootstrapFewShotWithOptuna` require it. Breaking changes: • `optuna` is no longer installed by default; workflows using `MIPROv2` or `BootstrapFewShotWithOptuna` must now run `pip install dspy[optuna]` to restore the dependency.

DSPy 3.1.2

Mon, 19 Jan 2026 14:16:35 GMT

DSPy 3.1.2 exposes `timeout` and `straggler_limit` params in `Parallel` for finer execution control. • Exposes `timeout` and `straggler_limit` parameters in `Parallel` to control execution time limits and straggler handling in parallel pipelines.

DSPy 3.1.1

Mon, 19 Jan 2026 02:30:49 GMT

DSPy 3.1.1 adds RLM module, GEPA tool-description optimization, StreamListener generic types, and DSPy settings save/load. • Adds `dspy.RLM` module for reinforcement learning-style module execution, backed by an improved `PythonInterpreter`. • Adds `save` and `load` methods to DSPy settings, enabling persistence and restore of global configuration. • Adds tool description optimization for multi-agent systems in `dspy.gepa`, allowing GEPA to tune tool descriptions alongside prompts. • Enhances `StreamListener` to support generic type annotations for output, enabling typed streaming results. • Uses `language` field in system instructions for `dspy.Code` fields to guide code-generation formatting. Breaking changes: • `FinalAnswerResult` is renamed to `FinalOutput` in `dspy.RLM`, and the `RLM.__call__` method is removed — code calling `RLM` as a callable or referencing `FinalAnswerResult` will break.

DSPy 3.1.0

Tue, 06 Jan 2026 18:48:05 GMT

DSPy 3.1.0 adds `dspy.Reasoning`, a `File` type, disable-fallback for ChatAdapter, and PKL-load guards. • Adds `dspy.Reasoning` type to capture native chain-of-thought reasoning output directly from reasoning models. • Adds `File` type (`dspy.File`) for passing file data through DSPy signatures and pipelines. • Adds a disable-fallback option in `ChatAdapter` to prevent silent adapter fallback during inference. • Adds guards against loading `.pkl` files by default, and a parameter to `load_memory_cache` to block PKL files unless explicitly opted in. • Adds a method to extract the system message based on a given adapter and signature. • Extends the stream listener to work on any output type, not only strings. • Adds official support for Python 3.14.

DSPy 3.0.4

Mon, 10 Nov 2025 17:41:17 GMT

DSPy 3.0.4 adds Anthropic Citations, ToolCall.execute, MLflow/GEPA integration, custom GEPA component selection, and Arbor GRPO support. • Adds `gepa_kwargs` parameter to pass custom keyword arguments to `gepa.optimize`, enabling per-run optimizer configuration. • Adds `ToolCall.execute` method for smoother programmatic tool execution in agentic pipelines. • Adds `save` and `load` methods to `Embeddings` for persisting embedding state. • Exposes `dspy.evaluate.EvaluationResult` as a first-class public symbol. • Adds Anthropic Citation API support, with a new `dspy.Document` primitive and citation-aware response handling. • Adds custom `instruction_proposer` support to GEPA, including multimodal `dspy.Image` handling. • Adds custom component selection logic to GEPA via a new selection callback. • Adds MLflow integration with GEPA for experiment tracking during optimization. • Adds Arbor GRPO sync update and an updated Arbor interface for reinforcement-learning-based optimization. • Allows custom types to be streamed and consumed via native response fields. • Adds a DSPy `User-Agent` header to outgoing LM requests, with support for overriding headers when specified. • Adds automatic `llms.txt` generation for documentation via the `mkdocs-llmstxt` plugin. • Supports CSV output (PR #8725), expanding the formats available for evaluation results. • Caches `Image.format` for improved throughput when working with `dspy.Image` inputs. • Deprecates `Image.from_*` helper methods in favor of a flexible unified `Image` constructor.

DSPy 3.0.3

Sun, 31 Aug 2025 18:47:21 GMT

DSPy 3.0.3 adds `rollout_id` for namespaced LM cache bypassing and automatic temperature scaling across multiple rollouts. • Adds `rollout_id` parameter to bypass the LM cache in a namespaced way, allowing distinct rollout sessions to avoid cache collisions. • Automatically raises temperature when executing multiple rollouts, and warns when temperature would otherwise remain flat across them.

DSPy 3.0.2

Fri, 22 Aug 2025 11:14:18 GMT

DSPy 3.0.2 adds OpenAI Responses API support and custom stream chunk types in LM calls. • Supports the OpenAI Responses API inside the `LM` class, enabling use of that endpoint alongside existing chat/completion modes. • Allows custom chunk types in streaming via `dspy.LM` stream handling, giving callers control over how streamed output is parsed. • Recognizes `gpt-5-nano` as a reasoning model, applying appropriate inference behavior automatically.

DSPy 3.0.0

Tue, 12 Aug 2025 21:02:50 GMT

DSPy 3.0 adds GEPA/SIMBA/GRPO optimizers, new adapters, multimodal types, async/streaming, and native MLflow 3.0 observability. • Adds `dspy.GEPA` (Genetic-Pareto) optimizer that builds a Pareto tree of prompts, uses NL reflection to extract and validate lessons, and can produce shorter prompts while improving downstream performance. • Adds `dspy.GRPO` reinforcement-learning optimizer for compound AI systems via the new Arbor library. • Adds `dspy.SIMBA` prompt optimizer that learns from custom feedback, suited for agentic and long-horizon tasks. • Adds `dspy.BAMLAdapter` alongside built-in `dspy.ChatAdapter`, `dspy.JSONAdapter`, and `dspy.XMLAdapter`, with token/status streaming, async paths, and intelligent fallback to native LLM structured outputs. • Adds `dspy.Type` base class enabling custom types to work automatically with all adapters. • Adds multimodal I/O via `dspy.Image` and `dspy.Audio` types, including composite types such as `list[dspy.Image]` and Pydantic models. • Adds `dspy.History` and `dspy.ToolCalls` higher-level I/O types. • Adds `dspy.CodeAct` and `dspy.Refine` modules, and a more reliable `PythonInterpreter`. • Adds `dspy.syncify` utility for running optimizers on async DSPy programs. • Adds `dspy.Code` type (landed in b3). • Adds `Module.batch` with thread-safe DSPy settings for high-concurrency workloads. • Adds native async support across modules and adapters (Chat and JSON adapters fully async). • Adds intermediate status streaming and output streaming from any layer, plus per-module history and usage tracking via rich callbacks. • Adds stable save/load for full programs, including the prompt management layer exportable via Adapters. • Adds native observability with MLflow 3.0, covering tracing, optimizer tracking, and improved deployment flows. • Adds out-of-the-box support for MCP servers and LangChain tools as tooling integrations. • Upgrades `MIPROv2` with automatic hyperparameter selection for more reliable optimization. • Supports PEP 604 union types (e.g., `int | str`) in DSPy signatures. • Adds Windows support for MIPROv2 confirmation prompts. Breaking changes: • Community retrievers removed (#8073): unmaintained retriever integrations no longer ship; migrate to custom code or Tool/MCP integrations. • Python 3.9 support dropped; supported versions are 3.10–3.13. • The `dspy.Program` alias is removed; replace all uses with the concrete class. • Legacy `functional/` and `dsp/` clients, old caches, examples, and tests removed (deprecations promised in 2.5 applied during 2.6 release candidates). • `BaseType` renamed to `Type` (`dspy.Type`); any code referencing `BaseType` will break.

DSPy 3.0.0b3

Sat, 19 Jul 2025 16:52:19 GMT

DSPy 3.0.0b3 adds `dspy.Code`, `dspy.syncify`, and token streaming for `XMLAdapter` • Adds `dspy.Code` type for use in signatures, with an optional `language` parameter to specify the programming language of the expected code output. • Adds `dspy.syncify` to wrap async DSPy programs so they can be run through optimizers in synchronous contexts. • Adds token streaming support for `XMLAdapter`. • Renames `dspy.BaseType` to `dspy.Type` as the base class for custom structured types. Breaking changes: • `dspy.BaseType` is renamed to `dspy.Type`; code referencing `dspy.BaseType` will break after upgrading.

DSPy 3.0.0b2

Tue, 01 Jul 2025 02:32:34 GMT

DSPy 3.0.0b2 adds reusable stream listeners, PEP 604 union types in signatures, Gemini provider support, and format control for ToolCalls. • Adds `format` parameter to `ToolCalls` for controlling tool call output format. • Supports PEP 604 union types (e.g. `int | str`) in inline signatures, enabling modern Python type hint syntax in `dspy.Signature` definitions. • Adds Gemini as a supported LM provider. • Changes default model for the Databricks provider to `llama-4`. • Allows reusing the `StreamListener` across multiple streaming calls. • Changes the output interface of `evaluate` — the return value of `dspy.Evaluate` has changed. • Removes `pandas` and `datasets` from core dependencies, making the base install lighter. • Drops Python 3.9 support; minimum supported version is now Python 3.10. Breaking changes: • The `dspy.Program` alias is removed; use `dspy.Module` directly. • Python 3.9 is no longer supported; upgrade to Python 3.10 or higher. • `pandas` and `datasets` are no longer installed as core dependencies; code that relied on them being available transitively will break. • The output interface of `evaluate` (the `dspy.Evaluate` return value) has changed. • The `Hyperparameter` class is removed. • The experimental module is removed. • `dspy.settings` entries related to `dspy.Assertion` are removed. • The `aws` extra dependency group is removed; AWS-related dependencies must now be installed separately.

DSPy 3.0.0b1

Wed, 11 Jun 2025 18:32:47 GMT

DSPy 3.0.0b1 adds a global `max_errors` setting, an XML adapter, expanded `PythonInterpreter` permissions, and async-to-sync tool conversion. • Adds global `max_errors` setting (via `dspy.settings`) to cap the number of errors tolerated across a DSPy program run. • Adds `xml adapter` as a new prompt/response adapter alongside the existing JSON adapter. • Expands permission capabilities in `PythonInterpreter` to support broader sandboxed code execution scenarios. • Supports automatic async-to-sync conversion for tools used in `dspy.ReAct` and similar modules, enabling async tool functions to be called in synchronous contexts. • Merges async settings changes into main, broadening asynchronous execution configuration. Breaking changes: • Community retriever integrations have been removed (PR #8073); programs using unmaintained retriever integrations must migrate to custom retriever code.

DSPy 2.6.26

Tue, 03 Jun 2025 16:56:31 GMT

DSPy 2.6.26 adds `dspy.Tool` as an input field type and `dspy.ToolCall` as an output field type. • Supports `dspy.Tool` as an input field type and `dspy.ToolCall` as an output field type, enabling typed tool-calling signatures in DSPy programs.

DSPy 2.6.25

Mon, 02 Jun 2025 21:00:08 GMT

DSPy 2.6.25 adds CodeAct module, dspy.Audio type, LangChain tool support, and per-module LM history tracking. • Adds `dspy.Audio` as a new built-in field type for passing audio inputs through Signatures. • Adds `CodeAct` module (`dspy.CodeAct`) enabling code-execution-based agentic reasoning loops. • Adds LangChain tool support, allowing LangChain tools to be used directly within DSPy modules. • Adds per-module LM history, enabling each module instance to track its own LM call history independently. • Adds a standard base class for creating custom Signature field types, enabling user-defined typed fields in Signatures. • Adds custom type resolution in Signatures for more flexible type handling in custom field definitions. • Supports Service Principal Auth for Databricks Retrieve, enabling non-interactive credential flows. • Supports custom imported module serialization via `cloudpickle` for more robust program save/load workflows. • Extends `dspy.Image` to accept `gs://` URLs from Google Cloud Platform. • Supports Python 3.13. • Streaming support extended to models that do not split stream chunks at token boundaries.

DSPy 2.6.24

Sat, 17 May 2025 02:31:38 GMT

DSPy 2.6.24 adds the GRPO optimizer and a new AdapterParseError exception class. • Adds `AdapterParseError` exception class to `dspy` for catching adapter parsing failures programmatically. • Adds `GRPO` optimizer to DSPy for reinforcement-learning-style prompt/weight optimization. • Improves sync streaming ergonomics, making it easier to consume streamed LM responses without async. • Adds better defaults and warnings around LM `max_tokens` to surface misconfiguration earlier.

DSPy 2.6.23

Mon, 05 May 2025 15:17:52 GMT

DSPy 2.6.23 adds async streaming support and token streaming with the JSON adapter. • Supports streaming in async DSPy programs, enabling real-time token delivery in async execution contexts. • Supports token streaming with the JSON adapter, so structured-output pipelines can now stream tokens incrementally. • Adds a utility to convert an async stream to a sync stream, bridging async streaming sources into synchronous DSPy programs. • Updates MIPROv2 auto settings and general optimizer behavior.

DSPy 2.6.22

Wed, 30 Apr 2025 14:42:00 GMT

DSPy 2.6.22 adds async support to ReAct and caching for async LM calls, plus custom types in MCP tools. • Adds async execution path to `dspy.ReAct`, enabling non-blocking agent loops in async applications. • Adds caching support for async LM calls, bringing async usage to parity with the synchronous cache behavior. • Supports arguments of custom types in `dspy` MCP tool definitions, expanding the range of tool signatures that can be expressed. • Improves adapter handling of Python `Literal` and `Optional` types for more robust input/output validation.

DSPy 2.6.20

Mon, 28 Apr 2025 16:37:58 GMT

DSPy 2.6.20 adds native async support for callbacks and dspy.Tool, plus MCP tool integration via dspy.Tool.from_mcp_tool. • Adds `dspy.Tool.from_mcp_tool` class method to construct a `dspy.Tool` directly from an MCP tool, enabling Model Context Protocol integration. • Adds native async support for callbacks and `dspy.Tool`, allowing asynchronous execution throughout the DSPy module pipeline.

DSPy 2.6.19

Thu, 24 Apr 2025 20:00:17 GMT

DSPy 2.6.19 adds async support on critical paths, a fanout cache, and expanded dspy.Tool argument handling. • Supports composite argument type parsing in `dspy.Tool`, enabling richer type hints for tool inputs. • Supports `kwargs` in `dspy.Tool`, allowing tools to accept variable keyword arguments. • Allows overwriting `max_iter` at runtime in `ReAct`, giving per-invocation control over agent loop depth. • Adds async support across DSPy critical paths, enabling non-blocking LM calls in async workflows. • Introduces a fanout cache for DSPy, enabling parallel cache lookups to reduce latency.

DSPy 2.6.18

Fri, 18 Apr 2025 19:54:32 GMT

DSPy 2.6.18 adds global `num_threads`/`provide_traceback` settings, a two-step adapter, streaming support, and default args in `dspy.Tool`. • Moves `num_threads` into `dspy.settings` so thread concurrency can be configured globally instead of per-call. • Moves `provide_traceback` into `dspy.settings` for global traceback control across all modules. • Adds a maximum size cap for the global history to bound memory growth during long runs. • Introduces a two-step adapter for improved structured-output handling. • Supports default argument values in `dspy.Tool`, reducing boilerplate when wrapping functions with optional parameters. • Adds generic streaming support across optimizers and modules.

DSPy 2.6.16

Fri, 28 Mar 2025 22:48:55 GMT

DSPy 2.6.16 adds usage tracking and SIMBA trial logs. • Adds trial logs to the SIMBA optimizer, surfacing per-trial diagnostic information during optimization runs. • Adds usage tracking to monitor LLM call statistics across DSPy programs.

DSPy 2.6.15

Mon, 24 Mar 2025 15:24:42 GMT

DSPy 2.6.15 ships the experimental SIMBA optimizer, more customizable ChainOfThought, and multi-output ProgramOfThought. • Adds experimental `dspy.SIMBA` optimizer with an accompanying Tool-Use Tutorial. • Allows `dspy.ChainOfThought` to be more customizable. • Allows `dspy.ProgramOfThought` to accept multiple output fields.

DSPy 2.6.14

Fri, 21 Mar 2025 18:40:05 GMT

DSPy 2.6.14 adds context-manager protocol support to PythonInterpreter and a new construct_result_table method on Evaluate. • Adds context-manager protocol (`with` statement) support to `PythonInterpreter`, enabling cleaner resource management when executing sandboxed Python code. • Introduces `construct_result_table` method on the `Evaluate` class, exposing structured result tables from evaluation runs.

DSPy 2.6.13

Wed, 19 Mar 2025 05:15:23 GMT

DSPy 2.6.13 adds image support to JSONAdapter, Pydantic field constraints in adapters, and extensible BaseLM. • Adds image support to `dspy.JSONAdapter`, enabling multimodal inputs through the JSON adapter alongside the existing chat adapter. • Supports Pydantic field constraints in DSPy adapters, allowing typed output fields to carry validation rules (e.g. min/max length, numeric bounds). • Makes `dspy.BaseLM` extensible, allowing custom LM subclasses to override and extend base behavior. • Adds `compile` and `get_params` methods to the `Teleprompter` base class, standardizing the optimizer interface. • Allows `dspy.ChatAdapter` parser to accept field headers and content on the same line, broadening the range of parseable model outputs. • Improves `dspy.BestOfN` with enhanced error handling.

DSPy 2.6.12

Thu, 13 Mar 2025 19:58:40 GMT

DSPy 2.6.12 adds `callback_metadata` to evaluate and simplifies `dspy.LM` • Adds `callback_metadata` parameter to the `evaluate` function, enabling richer context to be passed through evaluation callbacks. • Simplifies the `dspy.LM` interface.

DSPy 2.6.11

Mon, 10 Mar 2025 18:51:49 GMT

DSPy 2.6.11 adds Python 3.13 support and timeout-based straggler resubmission in ParallelExecutor. • Adds timeout-based straggler resubmission in `ParallelExecutor`, preventing slow tasks from blocking parallel evaluation runs. • Supports Python 3.13, unblocking use of DSPy on the latest Python release. • Reduces memory usage at `import dspy` startup.

DSPy 2.6.10

Tue, 04 Mar 2025 03:14:05 GMT

DSPy 2.6.10 adds support for non-image MIME types in image_url content fields. • Supports non-image MIME types in `image_url` content, enabling multimodal inputs beyond images.

DSPy 2.6.9

Mon, 03 Mar 2025 20:35:59 GMT

DSPy 2.6.9 adds multi-turn history support, an evaluate callback, and a `provide_traceback` option for MIPRO. • Allows passing `provide_traceback` to MIPRO optimizer runs to surface full tracebacks during optimization. • Adds evaluate callback support, enabling hooks into the evaluation lifecycle. • Supports multi-turn conversation history in DSPy modules.

DSPy 2.6.6

Mon, 24 Feb 2025 06:43:28 GMT

DSPy 2.6.6 adds `dspy.Refine` and `dspy.BestOfN` modules for iterative and best-of-N generation strategies. • Adds `dspy.Refine` module for iterative refinement of generated outputs. • Adds `dspy.BestOfN` module for sampling multiple candidate outputs and selecting the best one.

DSPy 2.6.5

Thu, 20 Feb 2025 01:28:55 GMT

DSPy 2.6.5 adds multitenancy support for Weaviate vector store integration. • Adds multitenancy support to the Weaviate integration, enabling tenant-isolated retrieval in multi-tenant Weaviate deployments.

DSPy 2.6.3

Sun, 16 Feb 2025 03:20:10 GMT

DSPy 2.6.3 adds status streaming support and context truncation for ReAct agents • Supports status streaming via `dspy.streamify`, now using context instead of settings for improved isolation. • Adds context truncation logic for `ReAct` to prevent runaway context growth in long agentic loops. • Improves `dspy.Tool` with enhancements to tool invocation behavior.

DSPy 2.6.2

Mon, 03 Feb 2025 15:41:58 GMT

DSPy 2.6.2 adds the InferRules optimizer and multimodal example support with dspy.Image. • Adds `InferRules` optimizer for automated rule inference during prompt optimization. • Supports arbitrary `dspy.Image` objects inside DSPy examples, enabling multimodal training and optimization workflows.

DSPy 2.6.1

Mon, 03 Feb 2025 11:28:35 GMT

DSPy 2.6.1 adds o3-mini support, separates in-memory cache from LiteLLM, and lets production deployments skip history writes. • Adds `DSP_CACHEBOOL` environment variable support: setting it to false skips cache initialization entirely. • Separates DSPy's in-memory cache from the LiteLLM cache, giving independent control over each layer. • Adds a new option to disable DSPy's write-to-history behavior for production deployments where history tracking is unwanted. • Moves the default joblib cache directory into `.dspy_cache` for cleaner local storage layout. • Adds support for `o3-mini` and other OpenAI reasoning models in the `lm` module. • Enables Optuna to learn from full evaluations when running MIPROv2 in minibatch mode, improving optimizer sample efficiency. • Enforces 3 demos in MIPROv2 meta-prompt for more consistent optimizer behavior. • Supports lists of models in module parameters.

DSPy 2.6.0

Thu, 30 Jan 2025 15:47:27 GMT

DSPy 2.6.0 adds streaming support, sandboxed Python interpreter, LiteLLM retry policy, and BootstrapFT improvements. • Adds streaming support via `dspy` (PR #1874), enabling real-time token-by-token output from LM calls. • Refactors the Python interpreter to run in a sandbox for safer code execution in agentic pipelines. • Supports LLM call retries via LiteLLM `RetryPolicy` integration. • Improves `BootstrapFT` optimizer relative to the 2.4 baseline. • Adds argument parsing support for `dspy.ReAct`. • Improves `Literal` type format adherence in `ChatAdapter` and `JSONAdapter`. • Refines thread-safety semantics for `Settings`. Breaking changes: • Removes deprecated `functional/` module — code importing from it will break. • Removes deprecated `dsp/` clients — code importing from them will break. • Removes old caches — any tooling relying on the previous cache layout will break.

DSPy 2.6.0rc8

Wed, 01 Jan 2025 17:09:56 GMT

DSPy 2.6.0rc8 adds AlfWorld dataset, sandboxed Python interpreter, and `dspy.__version__` introspection. • Exposes `dspy.__version__` for programmatic version introspection. • Refactors the Python interpreter tool to run in a sandbox for safer code execution. • Adds the AlfWorld dataset and an accompanying tutorial for interactive decision-making tasks. • Improves `BootstrapFT` optimizer behavior. • Allows `DatabricksRM` to return empty results when no documents are retrieved, instead of raising an error.

DSPy 2.6.0rc6

Sun, 22 Dec 2024 19:15:55 GMT

DSPy 2.6.0rc6 adds `response_model` key to LM history entries. • Adds `response_model` key to LM history entries, exposing the structured output model used for each language model call.

DSPy 2.6.0rc4

Wed, 18 Dec 2024 03:28:29 GMT

DSPy 2.6.0rc4 adds streaming support for language model calls. • Adds streaming support for language model outputs.

DSPy 2.6.0rc3

Tue, 17 Dec 2024 13:47:47 GMT

DSPy 2.6.0rc3 adds LiteLLM RetryPolicy support and thread-safe Settings semantics. • Supports automatic retries for LM calls via LiteLLM `RetryPolicy` integration. • Refines thread-safety semantics for `Settings` to make concurrent DSPy usage more reliable.

DSPy 2.5.43

Fri, 13 Dec 2024 15:01:17 GMT

DSPy 2.5.43 adds logprob support in Predictor and a new `docs_uri_column_name` field for DatabricksRM. • Adds `docs_uri_column_name` parameter to `DatabricksRM` to specify which column holds document URIs when retrieving results. • Enables returning log probabilities from `Predictor`, exposing token-level confidence scores for model outputs. • Improves DSPy module saving fidelity.

DSPy 2.5.42

Tue, 10 Dec 2024 15:45:17 GMT

DSPy 2.5.42 adds tool callbacks, in-memory LM caching, structured output support, and broader type coverage. • Adds `on_tool_start` and `on_tool_end` callbacks for observability hooks around tool execution. • Integrates `cachetools` for in-memory LM caching, with support for unhashable types and Pydantic models. • Supports structured outputs response format derived from the signature in the JSON adapter. • Expands supported types for DSPy signatures via broader type annotation handling. • Makes `DatabricksRM` compatible with the Mosaic agent framework.

DSPy 2.5.41

Fri, 29 Nov 2024 03:15:58 GMT

DSPy 2.5.41 adds Signature docstring context to ReAct and a new MATH reasoning dataset with metric and tutorial. • Includes the Signature `__doc__` string in the system message for the ReAct module, giving the LLM richer task context from inline documentation. • Adds a MATH reasoning dataset, accompanying metric, and tutorial for benchmarking and optimizing mathematical reasoning programs.

DSPy 2.5.40

Tue, 26 Nov 2024 17:21:51 GMT

DSPy 2.5.40 lets ReAct tools wrap class methods and serializes datetimes/enums via pydantic adapters. • Allows `react.Tool` to wrap class methods (not just standalone functions), expanding the surfaces that can be registered as ReAct tools. • Adapters now support JSON serialization of arbitrary pydantic-compatible types — including datetimes, enums, and other complex types — via pydantic's serialization layer. • Switches DSPy settings storage from a contextvar to thread-local storage, improving compatibility with Colab and multi-threaded environments.

DSPy 2.5.36

Sun, 24 Nov 2024 16:33:42 GMT

DSPy 2.5.36 converts settings to a ContextVar and allows user-launched threads to inherit DSPy context safely. • Converts `dspy.settings` to a `ContextVar`, enabling per-thread/per-context isolation of DSPy configuration. • Extends `ParallelExecutor` to isolate context even when running with a single thread. • Permits user-launched threads to carry DSPy settings context, enabling safe concurrent use outside of DSPy-managed execution.

DSPy 2.5.35

Sun, 24 Nov 2024 06:26:09 GMT

DSPy 2.5.35 raises the default cache limit to 30 GB. • Expands the default cache limit from its previous size to 30 GB, enabling larger-scale LM call caching without manual configuration.

DSPy 2.5.34

Fri, 22 Nov 2024 20:14:15 GMT

DSPy 2.5.34 adds a thread-safe faiss kNN retriever, a grounded completeness metric, and an Unbatchify utility. • Adds `dspy.retrievers.Embeddings` — a thread-safe, memory-friendly faiss k-nearest-neighbour retrieval index. • Introduces `CompleteAndGrounded` metric for evaluating whether generated outputs are both complete and grounded in source context. • Introduces `Unbatchify` utility for converting batched outputs back into individual items.

DSPy 2.5.33

Fri, 22 Nov 2024 02:21:34 GMT

DSPy 2.5.33 adds a teacher module to MIPROv2 and improves its logging. • Adds a teacher module to MIPROv2, enabling separate teacher-student optimization configurations. • Improves MIPROv2 logging output for better visibility into optimization runs.

DSPy 2.5.30

Sat, 16 Nov 2024 23:54:39 GMT

DSPy 2.5.30 adds `dspy.asyncify` for async module wrapping and native parallel execution support. • Adds `dspy.asyncify` to wrap synchronous DSPy modules for asynchronous execution. • Adds native parallel execution support via `ParallelExecutor` for running DSPy programs concurrently.

DSPy 2.5.29

Fri, 08 Nov 2024 19:29:46 GMT

DSPy 2.5.29 adds a Databricks finetuning integration. • Adds Databricks finetuning integration, enabling DSPy programs to leverage Databricks-hosted model finetuning workflows.

DSPy 2.5.28

Thu, 07 Nov 2024 22:53:22 GMT

DSPy 2.5.28 revamps BootstrapFinetune, merges BetterTogether optimizer, and adds a flag to suppress LiteLLM logs in dspy.LM. • Adds a flag to `dspy.LM` to suppress LiteLLM log output, reducing noise when running DSPy programs. • Revamps `BootstrapFinetune` and promotes the `BetterTogether` optimizer from experimental to main, making combined few-shot and fine-tuning optimization available in the standard release.

DSPy 2.5.26

Wed, 06 Nov 2024 02:41:47 GMT

DSPy 2.5.26 adds exponential backoff retries for LM calls and drops the structlog dependency. • Removes the `structlog` dependency, reducing the library's install footprint. • Adds automatic retry with exponential backoff for LM calls on a limited set of error codes.

DSPy 2.5.23

Sun, 03 Nov 2024 22:10:38 GMT

DSPy 2.5.23 adds image support and chainable loading for Predict modules. • Adds chainable loading for `Predict` modules, enabling fluent module initialization patterns. • Adds image support to DSPy programs.

DSPy 2.5.21

Wed, 30 Oct 2024 23:12:22 GMT

DSPy 2.5.21 adds automatic retries to LM calls via LiteLLM and enables ReAct to handle functions without docstrings. • Adds automatic retry support to LM calls made through LiteLLM, improving resilience against transient API failures. • Enables `ReAct` to handle tool functions that have no docstring, removing a previous hard requirement on function documentation. Breaking changes: • The `retry_strategy` parameter has been removed from `LM`; existing code that sets `retry_strategy` will break on upgrade.

DSPy 2.5.17

Sat, 26 Oct 2024 22:28:37 GMT

DSPy 2.5.17 introduces JsonAdapter with automatic retries and a new callback mechanism for LM pipeline observability. • Adds `JsonAdapter` as a new adapter alongside the improved `ChatAdapter`, with default retries built in for more resilient LM calls. • Adds a callback mechanism enabling hooks into DSPy module execution for observability and instrumentation. Breaking changes: • `dspy.TypedPredictor` and its variants are deprecated — callers should migrate to `dspy.Predict`, `dspy.ChainOfThought`, or other standard predictors.

DSPy 2.5.11

Wed, 16 Oct 2024 15:09:44 GMT

DSPy 2.5.11 adds SemanticF1 metric for evaluating semantic similarity of generated answers. • Adds `SemanticF1` metric for evaluating semantic similarity between predicted and expected answers.

DSPy 2.5.10

Wed, 16 Oct 2024 01:35:03 GMT

DSPy 2.5.10 adds Text Embeddings Inference (TEI) support. • Adds support for Text Embeddings Inference (TEI) as an embedding backend.

DSPy 2.5.9

Tue, 15 Oct 2024 03:25:10 GMT

DSPy 2.5.9 adds reasoning/rationale support to MultiChainComparison. • Adds reasoning/rationale support to `MultiChainComparison`, enabling the module to incorporate chain-of-thought rationale when comparing multiple completions.

DSPy 2.5.4

Tue, 08 Oct 2024 22:24:41 GMT

DSPy 2.5.4 adds `num_retries` to typed signature optimization and filterable LM history content. • Adds `num_retries` parameter to `signature_opt_typed` to control retry behavior in typed signature optimization. • Enhances LM history with filterable content, enabling more targeted inspection of past interactions. • Formats Pydantic fields as JSON in `chat_adapter`, improving structured output handling for chat-based LMs.

DSPy 2.5.1

Sat, 28 Sep 2024 16:38:18 GMT

DSPy 2.5.1 publishes to the `dspy` PyPI package name alongside `dspy-ai`. • Publishes the package to `dspy` on PyPI in addition to `dspy-ai`, so users can install with `pip install dspy`.

DSPy 2.5.0

Mon, 23 Sep 2024 21:13:48 GMT

DSPy 2.5.0 adds type casting and enforcement to adapters with a migration notebook. • Adds type casting and enforcement to adapters, with an accompanying migration notebook to guide upgrades from older patterns.

DSPy 2.4.16

Fri, 13 Sep 2024 13:18:37 GMT

DSPy 2.4.16 introduces new dspy.LM and dspy.Adapter classes and adds support for o1 model parameters. • Adds `dspy.LM` and `dspy.Adapter` classes, foundational new interfaces for language model and adapter management in DSPy 2.5 onwards (existing clients are unaffected). • Supports o1 model parameters in `dspy` LM configuration. • Enables LangChain objects to be copied within DSPy workflows.

DSPy 2.4.13

Mon, 29 Jul 2024 19:56:25 GMT

DSPy 2.4.13 adds configurable LM/RM backoff time and LangChain tool execution support. • Adds `backoff_time` parameter to dspy.settings.configure() for configurable retry backoff across LM/RM providers. • Adds LangChain Tool Execution support.

DSPy v2.4.12

Mon, 08 Jul 2024 14:55:22 GMT

DSPy v2.4.12 lets you compile `dspy.Predict` and `dspy.ChainOfThought` directly and improves Chat LM adapter support. • Supports compiling `dspy.Predict` and `dspy.ChainOfThought` directly as Modules without wrapping them in a `dspy.Module` object. • Improves the `experimental=True` Chat LM adapter support (enabled via dspy.configure(experimental=True)) introduced in v2.4.11, refining zero-shot generation quality for Chat LMs including GPT-3.5, GPT-4, Llama3, Mixtral, and DBRX.

DSPy v2.4.11

Sat, 06 Jul 2024 23:11:47 GMT

DSPy v2.4.11 adds experimental adapter support for smoother Chat LM zero-shot generation via dspy.configure(experimental=True) • Enables dspy.configure(experimental=True) to activate new adapter support, improving zero-shot generation predictability and accuracy for Chat LMs including GPT-3.5, GPT-4, Llama3, Mixtral, and DBRX. • Adds initial support for new adapters with improved handling of Chat LM interactions.