The AI Toolchain — issue -373, October 31, 2024

Aider v0.59.0 adds glob support for /read-only, faster large-repo launch, and editor-model sanity checks.

$ git clone --branch v0.59.0 https://github.com/Aider-AI/aider.git
# already have the repo? check out this version:
$ git checkout v0.59.0

$ /read-only src/**/*.py

$ aider --skip-sanity-check-repo --model gpt-4o

• ›Adds shell-style filesystem auto-complete and glob support (e.g. src/**/*.py) to the /read-only command.
• ›New --skip-sanity-check-repo flag skips repository sanity checks at launch to speed up startup in large repos.
• ›The /settings command now includes the full announcement lines printed at launch for a complete config snapshot.
• ›Sanity-checks the --editor-model on launch, matching the validation already applied to main and weak models.
• ›Repo-map generation is now deterministic with improved caching logic.

Cline v2.0 streams edits live, cuts API requests 40%, and adds real-time cancel plus full OpenRouter model search.

$ git clone --branch v2.0.0 https://github.com/cline/cline.git
# already have the repo? check out this version:
$ git checkout v2.0.0

• ›Streams AI-generated edits directly into the editor with a yellow text-decoration animation showing progress in real time.
• ›Adds a Cancel button to stop mid-generation and redirect Cline before it goes off track.
• ›Replaces the rigid Tool Use / Function Calling API with a custom XML-tags approach (e.g., <read_file>, <execute_command>), reducing requests by ~40% for Claude 3.5 Sonnet and enabling reliable tool calling for non-Claude models like Llama and DeepSeek.
• ›Automatically fetches the full OpenRouter model list with pricing details, with search support (e.g., search "free" to find no-cost models).
• ›Relicensed from MIT to Apache 2.0 for stronger open-source protections.

Goose v0.9.5 adds Google vision support and updates the default Ollama model to qwen2.5.

$ git clone --branch v0.9.5 https://github.com/block/goose.git
# already have the repo? check out this version:
$ git checkout v0.9.5

• ›Adds vision support for Google provider, enabling image-based interactions.
• ›Updates the default Ollama model from mistral-nemo to qwen2.5.

Goose v0.9.4 adds Groq and o1 model support, a new run command, provider listing, keychain API key storage, and global goosehints.

$ git clone --branch v0.9.4 https://github.com/block/goose.git
# already have the repo? check out this version:
$ git checkout v0.9.4

$ goose providers list

• ›Adds Groq as a supported LLM provider.
• ›Supports OpenAI o1-preview and o1-mini deep thinking reasoner models.
• ›New goose run command for non-interactive session execution.
• ›New goose providers list command to enumerate available providers.
• ›Saves API keys to the system keychain automatically for users.

OpenHands 0.11.0 improves LLM-powered agent file editing.

$ git clone --branch 0.11.0 https://github.com/All-Hands-AI/OpenHands.git
# already have the repo? check out this version:
$ git checkout 0.11.0

• ›Improves agent file editing quality using LLM-based refinements.

OpenHands 0.10.0 ships a redesigned UI and adds Modal as a new sandbox runtime.

$ git clone --branch 0.10.0 https://github.com/All-Hands-AI/OpenHands.git
# already have the repo? check out this version:
$ git checkout 0.10.0

• ›New OpenHands UI with a redesigned interface for interacting with agents.
• ›Adds Modal sandbox support as an alternative runtime backend for agent execution.

OpenHands 0.9.8 lets you specify a custom config.toml path via command-line arguments.

$ git clone --branch 0.9.8 https://github.com/All-Hands-AI/OpenHands.git
# already have the repo? check out this version:
$ git checkout 0.9.8

• ›Supports specifying the config.toml location via command-line arguments, enabling flexible multi-environment deployments.

Zed v0.158.2 switches Anthropic model references to -latest aliases by default.

$ git clone --branch v0.158.2 https://github.com/zed-industries/zed.git
# already have the repo? check out this version:
$ git checkout v0.158.2

• ›Switches default Anthropic model names to -latest variants, keeping integrations automatically current without manual version pinning.

Zed v0.158.1 adds format-selections, vi terminal mode, vim regex option, and shebang-based language detection.

$ git clone --branch v0.158.1 https://github.com/zed-industries/zed.git
# already have the repo? check out this version:
$ git checkout v0.158.1

{
  "context": "VimControl && !menu",
  "bindings": {
    "/": ["vim::Search", { "regex": false }]
  }
}

• ›Adds editor: format selections action to format only the currently selected text via the primary language server.
• ›Adds editor: reload file command to reload the current file from disk.
• ›Adds a regex option to the vim::Search command, allowing regex search to be disabled by default in the keymap.
• ›Adds Alacritty vi mode support to the built-in terminal, activated with ctrl-shift-space, enabling motions to navigate the scrollback buffer.
• ›Adds :e[dit] and :e[dit]! vim ex commands, mapped to editor: reload file.

Zed v0.157.4 adds color swatches in LSP completions, C runnables, and regex/case args for Vim search commands.

$ git clone --branch v0.157.4 https://github.com/zed-industries/zed.git
# already have the repo? check out this version:
$ git checkout v0.157.4

{
  "context": "VimControl && !menu",
  "bindings": {
    "*": ["vim::MoveToNext", { "regex": false, "caseSensitive": false }],
    "#": ["vim::MoveToPrev", { "regex": false, "caseSensitive": false }]
  }
}

[
  {
    "label": "Run ${ZED_STEM}",
    "command": "gcc",
    "args": [
      "$ZED_FILE",
      "-o",
      "${ZED_DIRNAME}/${ZED_STEM}.out",
      "&&",
      "${ZED_DIRNAME}/${ZED_STEM}.out"
    ],
    "tags": ["c-main"]
  }
]

• ›Adds regex and caseSensitive arguments to vim::MoveToNext and vim::MoveToPrev commands, enabling per-binding control over regex and case-sensitive search behavior.
• ›Adds runnables for main functions in C, with a c-main tag for use in task configurations.
• ›Adds color swatch previews in the language server completions list.
• ›Streamlines new branch creation from the branch selector.
• ›Adds a notice in the activity indicator when an error occurs while loading the shell environment.

Zed v0.156.0 adds snippet management commands, terminal cursor shape setting, SSH assistant panel, llama3.2 support, and expanded Vim fold operations.

$ git clone --branch v0.156.0 https://github.com/zed-industries/zed.git
# already have the repo? check out this version:
$ git checkout v0.156.0

{
  "terminal": {
    "cursor_shape": "bar"
  }
}

• ›Adds snippets: configure snippets command to create and modify user snippets stored in ~/.config/zed/snippets.
• ›Adds snippets: open folder command to open the ~/.config/zed/snippets directory directly.
• ›Adds terminal.cursor_shape setting supporting values block, bar, hollow, and underline to control the terminal's default cursor shape.
• ›Adds editor.document_highlight.bracket_background theme field to set the background color of highlighted brackets, falling back to editor.document_highlight.read_background when unset.
• ›Adds new fold actions: cmd-k cmd-l (toggle folds), cmd-k cmd-0 (fold all), cmd-k cmd-j (unfold all), cmd-k cmd-[ (fold recursively), and cmd-k cmd-] (unfold recursively).

Zed v0.155.2 adds parallel inline AI assists, a 'Fix with Assistant' action, and new Vim motions

$ git clone --branch v0.155.2 https://github.com/zed-industries/zed.git
# already have the repo? check out this version:
$ git checkout v0.155.2

{
  "assistant": {
    "inline_alternatives": ["gpt-4o", "claude-3-5-sonnet"]
  }
}

{
  "node": {
    "disable_path_lookup": true
  }
}

• ›Adds assistant.inline_alternatives setting to configure additional models that run inline assists in parallel alongside the primary model.
• ›Adds a Fix with Assistant action on code with errors or warnings, letting the AI address diagnostics inline.
• ›Adds node.disable_path_lookup config key (true/false) to control whether Zed uses the Node.js binary on $PATH (now the default when Node ≥ v18 is found) instead of downloading its own.
• ›Adds icons to the file finder for faster visual identification of file types.
• ›Adds a notification when user settings or project-local settings fail to deserialize.

AutoGPT Platform beta v0.1.1 adds Claude latest model support, LLM token usage tracking, and credit metering for Jina and LLM blocks.

$ git clone --branch agpt-platform-beta-v0.1.1 https://github.com/Significant-Gravitas/AutoGPT.git
# already have the repo? check out this version:
$ git checkout agpt-platform-beta-v0.1.1

• ›Tracks LLM token usage across LLM blocks, enabling consumption visibility for platform operators.
• ›Adds credit metering for Jina/Search and LLM blocks so usage costs are accounted per execution.
• ›Adds the latest Claude model version as a supported LLM option in the platform.
• ›Merges the login and sign-in flows into a single unified authentication screen.
• ›Improves block positioning logic in the flow editor to handle collisions and variable block dimensions when adding new blocks.

AutoGPT Platform beta adds cross-flow block copy/paste, credential management, health endpoints, and sealed secrets.

$ git clone --branch agpt-platform-beta-v0.1.0 https://github.com/Significant-Gravitas/AutoGPT.git
# already have the repo? check out this version:
$ git checkout agpt-platform-beta-v0.1.0

• ›Adds a health endpoint to the Platform/Backend for monitoring and security checks.
• ›Adds a health router to the Platform for improved service monitoring.
• ›Introduces sealed secrets for protecting sensitive data in platform deployments.
• ›Introduces configmap support for builder configuration management.
• ›Adds copy-and-paste of blocks across different flows in the UI.

CrewAI 0.76.0 adds unsafe code execution support with Docker install and runtime checks.

$ git clone --branch 0.76.0 https://github.com/crewAIInc/crewAI.git
# already have the repo? check out this version:
$ git checkout 0.76.0

• ›Supports unsafe code execution with Docker install and running checks for sandboxed agent workflows.

CrewAI 0.74.0 adds model selection and API key submission via CLI, a new Memory Base, and migrates tooling to UV.

$ git clone --branch 0.74.0 https://github.com/crewAIInc/crewAI.git
# already have the repo? check out this version:
$ git checkout 0.74.0

• ›Migrates the project toolchain from Poetry to UV, with CLI adapted for UV workflows.
• ›New CLI capability to select models and submit API keys directly from the command line.
• ›Introduces a new Memory Base foundation for agent memory management.

CrewAI 0.70.1 adds Flows with a visual debugger, plus new CLI commands for scaffolding flows and tools.

$ git clone --branch 0.70.1 https://github.com/crewAIInc/crewAI.git
# already have the repo? check out this version:
$ git checkout 0.70.1

$ crewai create flow

$ crewai tool create <tool>

• ›New Flow feature enables structured, multi-step agentic pipelines.
• ›Flow visualizer lets practitioners inspect and debug Flow execution graphs.
• ›New crewai create flow command scaffolds a Flow project from the CLI.
• ›New crewai tool create <tool> command scaffolds a custom tool from the CLI.
• ›Adds Git validations when publishing tools to enforce clean repository state.

DSPy 2.5.17 introduces JsonAdapter with automatic retries and a new callback mechanism for LM pipeline observability.

$ git clone --branch 2.5.17 https://github.com/stanfordnlp/dspy.git
# already have the repo? check out this version:
$ git checkout 2.5.17

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

DSPy 2.5.11 adds SemanticF1 metric for evaluating semantic similarity of generated answers.

$ git clone --branch 2.5.11 https://github.com/stanfordnlp/dspy.git
# already have the repo? check out this version:
$ git checkout 2.5.11

• ›Adds SemanticF1 metric for evaluating semantic similarity between predicted and expected answers.

DSPy 2.5.10 adds Text Embeddings Inference (TEI) support.

$ git clone --branch 2.5.10 https://github.com/stanfordnlp/dspy.git
# already have the repo? check out this version:
$ git checkout 2.5.10

• ›Adds support for Text Embeddings Inference (TEI) as an embedding backend.

DSPy 2.5.9 adds reasoning/rationale support to MultiChainComparison.

$ git clone --branch 2.5.9 https://github.com/stanfordnlp/dspy.git
# already have the repo? check out this version:
$ git checkout 2.5.9

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

DSPy 2.5.4 adds num_retries to typed signature optimization and filterable LM history content.

$ git clone --branch 2.5.4 https://github.com/stanfordnlp/dspy.git
# already have the repo? check out this version:
$ git checkout 2.5.4

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

langchain-groq 0.2.1 adds support for tool_choice=any and tool_choice=required in Groq chat models.

$ git clone --branch langchain-groq==0.2.1 https://github.com/langchain-ai/langchain.git
# already have the repo? check out this version:
$ git checkout langchain-groq==0.2.1

• ›Supports tool_choice='any' and tool_choice='required' values when binding tools to Groq chat models, enabling stricter tool-use enforcement.

langchain-core 0.3.15 adds public model-annotation utils, Bedrock↔OpenAI tool conversion, message trimming, and VectorStore id/index improvements.

$ git clone --branch langchain-core==0.3.15 https://github.com/langchain-ai/langchain.git
# already have the repo? check out this version:
$ git checkout langchain-core==0.3.15

from langchain_core.messages.utils import convert_to_openai_messages
from langchain_core.messages import HumanMessage, AIMessage

messages = [HumanMessage(content='Hello'), AIMessage(content='Hi there!')]
openai_messages = convert_to_openai_messages(messages)
print(openai_messages)
# [{'role': 'user', 'content': 'Hello'}, {'role': 'assistant', 'content': 'Hi there!'}]

from langchain_core.indexing import index

index(
    docs,
    record_manager,
    vector_store,
    cleanup='incremental',
    source_id_key='source',
    vector_field='my_custom_embedding_field'
)

• ›Makes get_all_basemodel_annotations a public utility function for inspecting Pydantic model field annotations across the class hierarchy.
• ›Adds convert_to_openai_messages utility to convert LangChain messages to the OpenAI messages format.
• ›Adds convert_to_openai_tool support for Anthropic tool definitions, enabling cross-provider tool schema conversion.
• ›Adds support for converting Bedrock Converse tool definitions to OpenAI tool format.
• ›Adds utility functions for adding and subtracting UsageMetadata objects, plus additional detail fields on UsageMetadata.

langchain-community 0.3.4 adds Writer integration, Naver chat/embeddings, and new OpenAIAssistantV2Runnable parameters

$ git clone --branch langchain-community==0.3.4 https://github.com/langchain-ai/langchain.git
# already have the repo? check out this version:
$ git checkout langchain-community==0.3.4

from langchain_community.chat_models import ChatZhipuAI

llm = ChatZhipuAI(model="glm-4")
for chunk in llm.stream("Explain zero-trust networking in one paragraph."):
    print(chunk.content, end="")
    if chunk.response_metadata:
        print(chunk.response_metadata.get("token_usage"))
        print(chunk.response_metadata.get("model_name"))

• ›Adds new parameters to OpenAIAssistantV2Runnable for finer control over assistant invocation.
• ›Adds token_usage and model_name metadata fields to ChatZhipuAI stream() and astream() responses.
• ›Adds Writer LLM integration via a new community integration module.
• ›Adds Naver chat model and embeddings integration.
• ›Adds async Azure AD token provider support for Azure OpenAI.

LangChain Core 0.3.14 adds Bedrock-to-OpenAI tool conversion, single-message trimming, and faster InMemoryVectorStore.

$ git clone --branch langchain-core==0.3.14 https://github.com/langchain-ai/langchain.git
# already have the repo? check out this version:
$ git checkout langchain-core==0.3.14

• ›Supports converting Bedrock Converse tool format to OpenAI tool format, enabling cross-provider tool interoperability.
• ›Extends message trimming to work on single messages, not just sequences.
• ›Improves performance of InMemoryVectorStore.
• ›Makes get_all_basemodel_annotations part of the public API.
• ›Improves type checking for the tool decorator.

langchain-openai 0.2.4 adds JSON Schema response format passthrough and async Azure AD token provider support.

$ git clone --branch langchain-openai==0.2.4 https://github.com/langchain-ai/langchain.git
# already have the repo? check out this version:
$ git checkout langchain-openai==0.2.4

• ›Supports passing a raw JSON Schema object directly as the response format for OpenAI calls, bypassing previous schema conversion requirements.
• ›Adds async Azure AD token provider support for Azure OpenAI, enabling non-blocking credential refresh in async applications.

langchain-community 0.3.3 adds proxy support to RecursiveUrlLoader, TLS/auth for Infinispan VectorStore, CLOB datatype support for Oracle, and extended Cassandra metadata methods.

$ git clone --branch langchain-community==0.3.3 https://github.com/langchain-ai/langchain.git
# already have the repo? check out this version:
$ git checkout langchain-community==0.3.3

• ›Adds proxy support to RecursiveUrlLoader for crawling through HTTP proxies.
• ›Adds TLS and authentication support to the VectorStore Infinispan integration.
• ›Adds support for the CLOB datatype in the Oracle database integration.
• ›Extends metadata-related methods in the Cassandra Vector Store integration.
• ›Updates the Firecrawl Document Loader to v1 of the Firecrawl API.

langchain-openai 0.2.3 adds audio modality support and sets default temperature=1 for o1 models.

$ git clone --branch langchain-openai==0.2.3 https://github.com/langchain-ai/langchain.git
# already have the repo? check out this version:
$ git checkout langchain-openai==0.2.3

• ›Supports audio modality for OpenAI models, enabling audio-capable API interactions through the library.
• ›Sets default temperature=1 for o1 models, aligning with OpenAI's recommended parameter for that model family.

langchain-core 0.3.11 adds a convert_to_openai_messages utility for message format conversion.

$ git clone --branch langchain-core==0.3.11 https://github.com/langchain-ai/langchain.git
# already have the repo? check out this version:
$ git checkout langchain-core==0.3.11

• ›Adds convert_to_openai_messages utility function for converting messages to the OpenAI messages format.

langchain-couchbase 0.2.0 adds TTL support for caches and chat message history, plus Pydantic v2 compatibility.

$ git clone --branch langchain-couchbase==0.2.0 https://github.com/langchain-ai/langchain.git
# already have the repo? check out this version:
$ git checkout langchain-couchbase==0.2.0

• ›Adds TTL (time-to-live) support to Couchbase-backed caches and chat_message_history, enabling automatic expiry of cached entries and stored conversation history.
• ›Adds Pydantic v2 compatibility across the integration, aligning with langchain-core v0.3 requirements.

langchain-community 0.3.2 adds SambaStudio chat model, sqlite-vec vector store, and GVS-to-NetworkX graph conversions

$ git clone --branch langchain-community==0.3.2 https://github.com/langchain-ai/langchain.git
# already have the repo? check out this version:
$ git checkout langchain-community==0.3.2

• ›Adds sqlite-vec as a new vector store integration for lightweight, embedded vector similarity search.
• ›Adds SambaStudio chat model integration.
• ›Adds conversions from Graph Vector Store (GVS) to NetworkX for graph-based analysis workflows.
• ›Adds timeout control and retry logic for Unity Catalog (UC) tool execution.

LangChain Core 0.3.10 adds kwargs support for vector field customization and improves VectorStore ID handling.

$ git clone --branch langchain-core==0.3.10 https://github.com/langchain-ai/langchain.git
# already have the repo? check out this version:
$ git checkout langchain-core==0.3.10

• ›Adds **kwargs to index and aindex functions to support custom vector_field configuration in vector store indexing.
• ›Improves support for id in VectorStore, enabling more reliable document identity handling.
• ›Adds utility functions for adding and subtracting usage metadata.

langchain-fireworks 0.2.1 allows tool_choice with multiple tools and relaxes model_kwargs field validation.

$ git clone --branch langchain-fireworks==0.2.1 https://github.com/langchain-ai/langchain.git
# already have the repo? check out this version:
$ git checkout langchain-fireworks==0.2.1

• ›Supports tool_choice when multiple tools are provided, enabling tool selection control in multi-tool call scenarios.
• ›No longer raises an error for unrecognized fields passed via model_kwargs, allowing forward-compatible model configurations.

langchain-anthropic 0.2.2 adds richer token-usage detail via usage_metadata.

$ git clone --branch langchain-anthropic==0.2.2 https://github.com/langchain-ai/langchain.git
# already have the repo? check out this version:
$ git checkout langchain-anthropic==0.2.2

• ›Adds usage_metadata details to Anthropic model responses, exposing richer token-usage information.

langchain-core 0.3.9 adds detailed UsageMetadata fields and tolerates extra model_kwargs without errors.

$ git clone --branch langchain-core==0.3.9 https://github.com/langchain-ai/langchain.git
# already have the repo? check out this version:
$ git checkout langchain-core==0.3.9

• ›Adds details to UsageMetadata to expose richer token/usage information from model responses.
• ›Stops raising errors when unknown fields are passed in model_kwargs, improving forward compatibility with new model parameters.

LangGraph 0.2.40 adds DuckDB checkpointing, richer ToolNode error handling, and concurrency limiting for async executors.

$ git clone --branch 0.2.40 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.2.40

tool_node = ToolNode(tools, messages_key="chat_history")
condition   = tools_condition(messages_key="chat_history")

from langgraph.prebuilt import ToolNode

tool_node = ToolNode(
    tools,
    handle_tool_errors=(ValueError, KeyError),   # only catch these types
)

# — or use a callable for dynamic formatting —
tool_node = ToolNode(
    tools,
    handle_tool_errors=lambda exc: f"Tool failed: {type(exc).__name__}: {exc}",
)

• ›Adds DuckDB checkpointing support via the new langgraph-checkpoint-duckdb package.
• ›Adds messages_key parameter to ToolNode and tools_condition for flexible integration with non-standard state schemas.
• ›Enhances ToolNode error handling: accepts a boolean, custom string, callable, or tuple of exception types to selectively catch and format errors, and attaches status="error" to error tool messages.
• ›Adds concurrency limiting to AsyncBackgroundExecutor via max_concurrency config parameter and semaphore-based gated utility.
• ›Adds node_finished callback parameter to PregelRunner via CONFIG_KEY_NODE_FINISHED for node-completion hooks.

LangGraph SDK 0.1.35 adds error-handling control to wait and raises default timeouts to 300 s

$ git clone --branch sdk==0.1.35 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout sdk==0.1.35

result = await client.wait(thread_id, run_id, raise_error=False)
if "__error__" in result:
    print("Run failed:", result["__error__"])

• ›Adds raise_error parameter to LangGraphClient.wait and SyncLangGraphClient.wait, letting callers suppress exception raising and inspect error objects directly.
• ›Increases default read/write timeouts from 60 s to 300 s in get_client and get_sync_client, enabling reliable use with long-running graph operations.

LangGraph SDK 0.1.34 adds if_not_exists parameter and new "error" thread status for safer run handling.

$ git clone --branch sdk==0.1.34 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout sdk==0.1.34

async for chunk in client.runs.stream(
    thread_id=user_thread_id,
    assistant_id="my-assistant",
    input={"messages": [{"role": "user", "content": "Hello"}]},
    if_not_exists="create",
):
    print(chunk)

result = await client.runs.wait(
    thread_id=incoming_thread_id,
    assistant_id="my-assistant",
    input={"messages": [{"role": "user", "content": "Continue"}]},
    if_not_exists="reject",  # raises if thread_id not found
)

• ›Adds if_not_exists parameter to stream, create, and wait client methods, letting callers auto-create a missing thread ("create") or reject the operation ("reject") instead of always raising.
• ›Adds "error" as a valid ThreadStatus value, surfacing when an exception occurred during task processing.
• ›Widens type annotations for stream_mode, interrupt_before, interrupt_after, and feedback_keys from list to Sequence, accepting tuples and other sequences without casting.

LangGraph 0.2.39 adds TAG_NOSTREAM constant, structured error codes, and finer streaming control.

$ git clone --branch 0.2.39 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.2.39

from langgraph.constants import TAG_NOSTREAM

# When binding or invoking a chat model you want kept off the stream,
# pass TAG_NOSTREAM as a tag so StreamMessagesHandler skips it.
silent_model = llm.with_config({"tags": [TAG_NOSTREAM]})

# Use silent_model inside a node as normal — its tokens won't be streamed.
def my_node(state):
    result = silent_model.invoke(state["messages"])
    return {"messages": [result]}

from langgraph.errors import ErrorCode
from langgraph.errors import GraphRecursionError

try:
    graph.invoke(inputs)
except GraphRecursionError as e:
    if ErrorCode.GRAPH_RECURSION_LIMIT.value in str(e):
        # surface a user-friendly message or increase recursion_limit
        print("Graph hit recursion limit — consider increasing recursion_limit or breaking cycles.")

• ›New TAG_NOSTREAM constant in langgraph.constants lets you tag chat models to suppress their output from the stream.
• ›New ErrorCode enum in langgraph.errors provides standardized codes (GRAPH_RECURSION_LIMIT, INVALID_CONCURRENT_GRAPH_UPDATE, INVALID_GRAPH_NODE_RETURN_VALUE, MULTIPLE_SUBGRAPHS) for programmatic error handling.
• ›New create_error_message helper in langgraph.errors generates consistent error messages with links to troubleshooting documentation.
• ›StreamMessagesHandler now respects TAG_NOSTREAM on chat model starts and TAG_HIDDEN on chain starts for fine-grained control over what gets streamed.

LangGraph 0.2.37 adds RemainingSteps managed value and LoopProtocol for finer-grained loop termination control.

$ git clone --branch 0.2.37 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.2.37

from langgraph.managed import RemainingSteps

def agent_node(state, remaining_steps: RemainingSteps):
    if remaining_steps < 2:
        # Not enough headroom — return a safe fallback instead of calling tools
        return {"messages": [AIMessage(content="Stopping early: too few steps remaining.")]}
    # ... normal tool-calling logic
    return model_with_tools.invoke(state["messages"])

• ›Adds RemainingSteps managed value to expose the number of remaining steps during loop execution, usable alongside IsLastStep for precise loop control.
• ›Introduces LoopProtocol interface, giving managed values and channels structured access to loop execution context (config, store, stream, step, stop).
• ›Improves checkpointing in nested loops with proper parent configuration propagation via updated patch_checkpoint_map.

LangGraph 0.2.36 adds RemoteGraph for interacting with hosted LangGraph deployments via the LangGraph API.

$ git clone --branch 0.2.36 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.2.36

from langgraph.pregel.remote import RemoteGraph

remote_graph = RemoteGraph(
    url="https://my-deployment.langgraph.app",
    api_key="<your-api-key>",
    graph_id="my-graph"
)

async for chunk in remote_graph.astream({"input": "Hello"}):
    print(chunk)

• ›New RemoteGraph class enables invoking, streaming, and inspecting state on remote LangGraph deployments through the LangGraph API.
• ›New PregelProtocol defines a standard interface for interacting with graphs, providing both sync and async methods for state management, visualization, subgraph traversal, and execution.
• ›Adds a result field to PregelTask to store and access structured task execution results in state snapshots.

LangGraph SDK 0.1.33 adds wildcard node interrupts, custom stream mode, and richer update_state returns.

$ git clone --branch sdk==0.1.33 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout sdk==0.1.33

response = await client.threads.update_state(
    thread_id=thread_id,
    values={"messages": [{"role": "assistant", "content": "Corrected reply"}]},
)
print(response)  # ThreadUpdateStateResponse with checkpoint info

async for chunk in client.runs.stream(
    thread_id=thread_id,
    assistant_id=assistant_id,
    input={"messages": [{"role": "user", "content": "Hello"}]},
    stream_mode=["messages", "custom"],
):
    print(chunk)

• ›Supports passing "*" to interrupt_before/interrupt_after parameters in RunsClient and CronClient to interrupt all nodes without listing them individually.
• ›Adds "custom" option to StreamMode, giving more flexibility in how streams are handled.
• ›update_state now returns a ThreadUpdateStateResponse containing checkpoint information instead of None.
• ›Expands update_state values parameter to accept Sequence[dict] in addition to a single dict, enabling multi-dictionary state updates.

LangGraph 0.2.35 adds cross-thread memory for agents and a new find_subgraph_pregel utility for nested graph introspection.

$ git clone --branch 0.2.35 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.2.35

from langgraph.pregel.utils import find_subgraph_pregel

subgraph = find_subgraph_pregel(my_runnable)
if subgraph:
    print("Found Pregel subgraph:", subgraph)

• ›Adds cross-thread memory support in agent executors, enabling agents to retain information across separate conversation threads.
• ›Introduces find_subgraph_pregel utility to recursively locate Pregel subgraphs within runnable components — useful for checkpoint handling and graph introspection.
• ›Enhances map_debug_checkpoint to include task state information and properly maintain checkpoint namespaces for nested subgraph debugging.

AsyncPostgresStore now inherits from AsyncBatchedBaseStore, enabling efficient batched async operations.

$ git clone --branch checkpointpostgres==2.0.1 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpointpostgres==2.0.1

• ›Enables batched async operations in AsyncPostgresStore via AsyncBatchedBaseStore inheritance, reducing round-trips for high-throughput workloads.
• ›Adds explicit ORDER BY updated_at DESC to search queries in PostgresStore, providing consistent, deterministic result ordering.

LangGraph 0.2.34 adds a store parameter to create_react_agent for cross-thread persistence.

$ git clone --branch 0.2.34 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.2.34

from langgraph.prebuilt import create_react_agent

agent = create_react_agent(
    model=llm,
    tools=tools,
    checkpointer=checkpointer,  # single-thread (per-conversation) state
    store=store,                # cross-thread (multi-user) persistence
)

• ›Adds store parameter to create_react_agent, enabling data persistence across multiple threads (e.g., different users or conversations) alongside the existing checkpointer parameter.
• ›Adds a warning when InjectedStore annotation is used without langchain-core >= 0.3.8, surfacing the dependency requirement at runtime.

LangGraph 0.2.33 adds InjectedStore annotation so tools can read/write the LangGraph store without exposing it to the model.

$ git clone --branch 0.2.33 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.2.33

from typing import Annotated
from langgraph.prebuilt.tool_node import InjectedStore
from langgraph.store.base import BaseStore

def save_note(note: str, store: Annotated[BaseStore, InjectedStore()]) -> str:
    """Save a note to the store."""
    store.put(("notes",), "latest", {"text": note})
    return "Saved."

• ›Adds InjectedStore annotation to inject LangGraph store objects directly into tool arguments, hiding them from the tool-calling model (similar to InjectedState).
• ›Enhances ToolNode to automatically detect and inject the store for tools annotated with InjectedStore, with precomputed caching of state and store arguments for efficiency.
• ›Enables RunnableCallable keyword arguments to override config values in invoke and ainvoke, giving callers finer control over execution.

LangGraph SDK 0.1.32 adds a key-value Store API with namespaced put, get, delete, search, and list operations for both async and sync clients.

$ git clone --branch sdk==0.1.32 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout sdk==0.1.32

from langgraph_sdk import get_client

client = get_client()

# Store a user preference
await client.store.put_item(
    namespace=("users", "alice"),
    key="preferences",
    value={"theme": "dark", "language": "en"}
)

# Retrieve it later
item = await client.store.get_item(
    namespace=("users", "alice"),
    key="preferences"
)
print(item["value"])

from langgraph_sdk import get_client

client = get_client()

results = await client.store.search_items(
    namespace_prefix=("users",),
    filter={"language": "en"}
)
for item in results["items"]:
    print(item["namespace"], item["key"], item["value"])

from langgraph_sdk import get_sync_client

client = get_sync_client()

namespaces = client.store.list_namespaces(prefix=("users",))
for ns in namespaces["namespaces"]:
    print(ns)

• ›New StoreClient and SyncStoreClient classes provide async and sync key-value storage with put_item, get_item, delete_item, search_items, and list_namespaces methods.
• ›Adds store property to LangGraphClient and SyncLangGraphClient for direct access to the new store API.
• ›Exposes get_sync_client in module exports for easier access to the synchronous client.
• ›New Item, ListNamespaceResponse, and SearchItemsResponse TypedDicts formalize storage operation schemas.
• ›Adds output_schema field to the GraphSchema TypedDict.

Letta 0.5.0 adds env-var-driven multi-provider model listing, Groq/Mistral/vLLM support, agent types, automated DB migrations, and a multi-message POST API.

$ git clone --branch 0.5.0 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.5.0

$ export OPENAI_API_KEY=sk-...
export ANTHROPIC_API_KEY=sk-ant-...
export OLLAMA_BASE_URL=http://localhost:11434
letta server

• ›Enables model providers via environment variables (OPENAI_API_KEY, ANTHROPIC_API_KEY, OLLAMA_BASE_URL) so a single letta server can serve agents with different model configurations concurrently without restart.
• ›Adds VLLMProvider support, enabling vLLM-served models to appear in the CLI and ADE model dropdowns when configured.
• ›Adds Groq as a provider option, with Llama 3.1 70b available for selection.
• ›Adds MistralProvider as a new model provider option.
• ›Refactors the POST agent/messages API endpoint to accept multiple messages in a single request.

Letta 0.4.1 adds Composio, LangChain, and CrewAI tool integrations, source detachment, org endpoints, and a health-check route.

$ git clone --branch 0.4.1 https://github.com/letta-ai/letta.git
# already have the repo? check out this version:
$ git checkout 0.4.1

$ pip install 'letta[external-tools]'

• ›Adds letta[external-tools] install extra to enable Composio, LangChain, and CrewAI tool integrations with agents.
• ›Adds user_id header support to the API, allowing per-request user identification.
• ›Adds DEFAULT_USER_ID and DEFAULT_ORG_ID environment variables for local usage without explicit user/org setup.
• ›Adds organization endpoints and schemas to the REST API.
• ›Adds a health-check route to the server.

AutoGen v0.2.36 adds Mem0 long-term memory, Amazon Bedrock, Cerebras, Ollama (with tool calling), Couchbase VectorDB, and Portkey integrations.

$ git clone --branch v0.2.36 https://github.com/microsoft/autogen.git
# already have the repo? check out this version:
$ git checkout v0.2.36

from autogen.agentchat.contrib.capabilities.transform_messages import TransformMessages
from autogen.agentchat.contrib.capabilities.transforms import MessageHistoryLimiter
from autogen import GroupChat, GroupChatManager

transforms = TransformMessages(transforms=[MessageHistoryLimiter(max_messages=10)])

groupchat = GroupChat(
    agents=[agent1, agent2, agent3],
    messages=[],
    speaker_selection_method="auto",
    select_speaker_transform_messages=transforms,
)
manager = GroupChatManager(groupchat=groupchat, llm_config=llm_config)

• ›Adds Mem0 integration for long-term memory support in AI agents.
• ›Adds Amazon Bedrock client for model access via AWS.
• ›Adds Cerebras integration as a new LLM provider.
• ›Adds Ollama client with tool-calling support.
• ›Adds Couchbase VectorDB support for retrieval-augmented generation workflows.

Semantic Kernel Python 1.13.0 adds Ollama tool call and image content support plus parallel tool call control for OpenAI.

$ git clone --branch python-1.13.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.13.0

from semantic_kernel.connectors.ai.open_ai import OpenAIChatPromptExecutionSettings

settings = OpenAIChatPromptExecutionSettings(
    parallel_tool_calls=False
)

• ›Adds parallel_tool_calls attribute to OpenAI chat prompt execution settings, enabling control over whether OpenAI calls tools in parallel during a completion.
• ›Adds support for Ollama tool calls and image content, bringing multimodal and function-calling capabilities to the Ollama connector.
• ›Allows callers to specify pre-existing file IDs when creating an assistant, avoiding redundant file uploads.

Semantic Kernel Python 1.12.0 adds ONNX and AWS Bedrock connectors, PostgreSQL vector store, process framework, and structured output support.

$ git clone --branch python-1.12.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.12.0

• ›Adds 'low' severity level to the ContentFilterResultSeverity enum, expanding content filter granularity.
• ›Adds a new ONNX connector for local model inference via the Semantic Kernel connector interface.
• ›Adds a new AWS Bedrock connector for integrating Bedrock-hosted models.
• ›Adds Vector Store support to the PostgreSQL connector.
• ›Adds OpenAI Structured Output response_format support for constrained, schema-driven completions.

Semantic Kernel .NET 1.25.0 adds Pinecone vector search, MongoDB memory connector, SQL Server vector support, concurrent parallel function calls, and streaming tool call output.

$ git clone --branch dotnet-1.25.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.25.0

• ›Adds vector search support to the Pinecone connector for .NET.
• ›Adds a MongoDB connector implementation for the new memory/vector design in .NET.
• ›Adds SQL Server vector support (Dm/sqlserver/vector) for .NET.
• ›Invokes parallel function calls concurrently in .NET, enabling parallel tool execution in a single inference turn.
• ›Scopes step IDs to a process in .NET Processes, reducing cross-process ID collisions.

Semantic Kernel dotnet-1.24.1 adds a SQLite vector store connector and JSON Schema generation for .NET Processes.

$ git clone --branch dotnet-1.24.1 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.24.1

• ›Adds SQLite connector for the new memory/vector store design (Microsoft.SemanticKernel.Connectors.Sqlite or equivalent vectordata implementation).
• ›.NET Processes now generates JSON Schema from a Type directly, replacing manual schema definition.

Semantic Kernel .NET adds a Dapr runtime backend for the Process framework.

$ git clone --branch dotnet-1.24.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.24.0

• ›Adds a Dapr runtime for the Processes framework, enabling distributed, durable process orchestration via Dapr.

Semantic Kernel .NET 1.23.0 adds new Process error handling, fluent edge building, VectorStore search, ONNX and Bedrock connectors, and CreateFromType factory methods.

$ git clone --branch dotnet-1.23.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.23.0

• ›Adds OnError event handling exposure in .NET Processes via Expose OnError Event Handling, enabling structured error routing within process graphs.
• ›Adds fluent edge building API for .NET Processes, allowing process step connections to be defined with a fluent builder pattern.
• ›Adds CreateFromType and CreateMetadataFromType static factory methods for constructing kernel function metadata from CLR types.
• ›Adds AddVectorStoreTextSearch support for service IDs on dependencies, allowing named DI registrations to be resolved for text search services.
• ›Adds collection registration methods for the InMemory vector store connector, enabling IVectorStore collection lifecycle management in-process.

Semantic Kernel 1.22.0 adds sub-process support, code-interpreter streaming, usage metadata, and richer ITextToImageService abstractions.

$ git clone --branch dotnet-1.22.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout dotnet-1.22.0

• ›Adds optional version parameter to Azure OpenAI API connectors, allowing callers to pin a specific API version per request.
• ›Expands ITextToImageService abstractions to support ExecutionSettings, enabling per-call generation configuration.
• ›Adds token usage and other metadata to Assistant agent responses for cost and observability tracking.
• ›Adds usage metadata to OpenAI streaming chunks, surfacing token counts during streamed completions.
• ›Implements generic data model support for the Weaviate connector, matching the generic data model pattern available in other vector store connectors.

Semantic Kernel Python 1.11.0 adds streaming support for OpenAI Assistants and improved Anthropic function calling.

$ git clone --branch python-1.11.0 https://github.com/microsoft/semantic-kernel.git
# already have the repo? check out this version:
$ git checkout python-1.11.0

• ›Adds streaming support for OpenAI Assistants, enabling real-time token-by-token output from assistant runs.
• ›Updates Anthropic function calling to support latest function-calling capabilities in the Anthropic integration.

camel-ai v0.2.2 adds Llama tool calling, Nebula Graph integration, Mistral Pixtral support, and bytes handling for vector retrieval.

$ git clone --branch v0.2.2 https://github.com/camel-ai/camel.git
# already have the repo? check out this version:
$ git checkout v0.2.2

• ›Adds tool calling support for Llama models.
• ›Adds Nebula Graph integration for graph-based storage and retrieval.
• ›Supports the Mistral Pixtral multimodal model.
• ›Adds support for handling bytes input in vector retrieval.

HolmesGPT 0.4.0 adds tool_calls to the /api/conversation endpoint and lets you override the UI token via environment variable.

$ git clone --branch 0.4.0 https://github.com/HolmesGPT/holmesgpt.git
# already have the repo? check out this version:
$ git checkout 0.4.0

• ›The POST /api/conversation endpoint now returns tool_calls in its response, exposing which tools Holmes invoked during an investigation.
• ›Allows overriding the UI token with an environment variable instead of requiring it to be set in config.
• ›Improves CLI logging and expands the --verbose flag for more detailed diagnostic output.
• ›Improves prompt output to produce more detailed investigation results.

Jan v0.5.5 adds textarea auto-resize and an enhanced tabbed model-selection UI.

$ git clone --branch v0.5.5 https://github.com/janhq/jan.git
# already have the repo? check out this version:
$ git checkout v0.5.5

• ›Adds auto-resizing textarea in the chat input area, expanding as content grows.
• ›Enhances the model selection UI with a new tabs component for browsing models.

LocalAI v2.22.0 adds vLLM video/image-to-text, a tokenization endpoint, loaded-model listing via /system, and configurable multimodal placeholders.

$ git clone --branch v2.22.0 https://github.com/mudler/LocalAI.git
# already have the repo? check out this version:
$ git checkout v2.22.0

$ curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o",
    "messages": [
      {
        "role": "user",
        "content": [
          {"type": "text", "text": "What is in this video?"},
          {"type": "video_url", "video_url": {"url": "https://example.com/clip.mp4"}}
        ]
      }
    ],
    "max_tokens": 300
  }'

template:
  image: "<|image_{{.ID}}|> {{.Text}}"
  video: "<|video_{{.ID}}|> {{.Text}}"
  audio: "<|audio_{{.ID}}|> {{.Text}}"

• ›Adds template.video, template.image, and template.audio keys to model YAML config to override per-backend multimodal placeholder notation (e.g. <|video_{{.ID}}|> {{.Text}}).
• ›Extends the chat completions API to accept video_url and audio content types alongside images, enabling video and audio understanding via the vLLM backend.
• ›Lists all currently loaded models via the GET /system endpoint for real-time model management.
• ›Adds a tokenization endpoint to the API.
• ›Adds token metrics retrieval to the GRPC server.

SGLang v0.3.2 adds multi-LoRA serving, AMD/ROCm support, torchao quantization, and a new --attention-backend flag.

$ git clone --branch v0.3.2 https://github.com/sgl-project/sglang.git
# already have the repo? check out this version:
$ git checkout v0.3.2

$ python -m sglang.launch_server --model-path meta-llama/Meta-Llama-3-8B --attention-backend triton

• ›Introduces --attention-backend CLI flag to select the attention backend, replacing the deprecated --disable-flashinfer.
• ›Adds constrained_json_whitespace_pattern to ServerArgs for fine-grained control over JSON whitespace in constrained decoding.
• ›Passes model_override_args to launch_server via the CLI, enabling runtime model config overrides without code changes.
• ›Supports OpenAI API json_schema response format for structured output.
• ›Supports response prefill via the OpenAI-compatible API.

oobabooga textgen v1.15 adds XTC sampler, sortable repetition penalties, and ExLlamaV2 tensor parallelism for multi-GPU inference.

$ git clone --branch v1.15 https://github.com/oobabooga/textgen.git
# already have the repo? check out this version:
$ git checkout v1.15

• ›Adds xtc to the Sampler priority ordering keywords, alongside new keywords repetition_penalty, presence_penalty, frequency_penalty, dry, encoder_repetition_penalty, and no_repeat_ngram, enabling fine-grained control over the order repetition penalties are applied.
• ›Adds Exclude Top Choices (XTC) sampler to boost creativity, break writing clichés, and inhibit non-verbatim repetition.
• ›Enables ExLlamaV2 tensor parallelism to increase multi-GPU inference speeds.
• ›Removes AutoAWQ, AutoGPTQ, HQQ, and AQLM from requirements.txt; these can still be installed manually.
• ›Adds a beforeunload confirmation dialog when leaving the page to prevent accidental session loss.

vLLM v0.6.3 adds Granite MoE, Mamba, GLM-4V, Molmo, NVLM-D, Molmo vision models, Llama 3.1/3.2 tool use, and VLLM_TORCH_COMPILE_LEVEL env var for full Inductor graph compilation.

$ git clone --branch v0.6.3 https://github.com/vllm-project/vllm.git
# already have the repo? check out this version:
$ git checkout v0.6.3

$ VLLM_TORCH_COMPILE_LEVEL=3 vllm serve meta-llama/Llama-3.1-8B-Instruct

$ VLLM_SKIP_P2P_CHECK=1 vllm serve meta-llama/Llama-3.1-70B-Instruct --tensor-parallel-size 4

• ›Adds VLLM_TORCH_COMPILE_LEVEL environment variable to control torch.compile compilation levels; setting VLLM_TORCH_COMPILE_LEVEL=3 enables Inductor full graph compilation without vLLM custom ops.
• ›Adds VLLM_SKIP_P2P_CHECK flag to skip peer-to-peer GPU connectivity checks in distributed deployments.
• ›Moves guided decoding params into SamplingParams, unifying the interface for structured-output control.
• ›Makes scheduling policy settable via EngineArgs, enabling priority-based scheduling to be configured at engine startup.
• ›Adds support for Llama 3.1 and 3.2 tool use via the tool calling interface.

Ollama v0.3.14 adds IBM Granite 3 MoE and Dense model support for low-latency and RAG/tool-use workloads.

$ git clone --branch v0.3.14 https://github.com/ollama/ollama.git
# already have the repo? check out this version:
$ git checkout v0.3.14

$ ollama run granite3-moe

$ ollama run granite3-dense

• ›Adds Granite 3 MoE (1B and 3B): IBM's first mixture-of-experts Granite models optimized for low-latency inference.
• ›Adds Granite 3 Dense (2B and 8B): IBM Granite models designed for tool-use, RAG, code generation, and translation.
• ›Supports the IBM Granite and GraniteMoE model architectures natively.

Ollama v0.3.13 adds Llama Guard 3 and ShieldGemma safety classification models for LLM input/output screening.

$ git clone --branch v0.3.13 https://github.com/ollama/ollama.git
# already have the repo? check out this version:
$ git checkout v0.3.13

• ›Adds Llama Guard 3 support: Meta's fine-tuned content safety classification models for screening LLM inputs and outputs.
• ›Adds ShieldGemma support: Google DeepMind's instruction-tuned models for evaluating text prompts and responses against defined safety policies.

Arize Phoenix v5.5.0 adds Anthropic support to subscription streaming.

$ git clone --branch arize-phoenix-v5.5.0 https://github.com/Arize-ai/phoenix.git
# already have the repo? check out this version:
$ git checkout arize-phoenix-v5.5.0

• ›Adds Anthropic model support to subscription streaming.

Phoenix 5.4.0 adds secure WSS connection support and playground span details on run completion.

$ git clone --branch arize-phoenix-v5.4.0 https://github.com/Arize-ai/phoenix.git
# already have the repo? check out this version:
$ git checkout arize-phoenix-v5.4.0

• ›Adds support for secure wss connections to Phoenix.
• ›Playground now returns the finalized span at the end of a subscription, making trace data available immediately after a run.
• ›Playground now displays span details when a run ends, surfacing trace information inline.

Phoenix 5.3.0 ships a full Playground UI for LLM span replay, streaming completions, tool calling, Azure OpenAI support, and a TypeScript client scaffold.

$ git clone --branch arize-phoenix-v5.3.0 https://github.com/Arize-ai/phoenix.git
# already have the repo? check out this version:
$ git checkout arize-phoenix-v5.3.0

• ›Playground replays LLM spans by parsing the llm.input_messages span attribute and pre-populating the prompt editor, letting teams iterate on prompts directly from a captured trace.
• ›Playground supports streaming chat completions, letting practitioners see model output token-by-token during interactive prompt tuning.
• ›Playground adds a tools UI with full tool-calling backend support, including wiring up tool choice to the model invocation.
• ›Playground supports Azure OpenAI as a provider alongside existing providers, with model name and provider inferred automatically from the span.
• ›Playground allows up to 4 side-by-side instances, distinguished alphabetically, for parallel prompt comparison.

Phoenix Evals now always sends prompts as system messages for OpenAI models.

$ git clone --branch arize-phoenix-evals-v0.17.0 https://github.com/Arize-ai/phoenix.git
# already have the repo? check out this version:
$ git checkout arize-phoenix-evals-v0.17.0

• ›OpenAI model evaluations now always send prompts as system-role messages instead of user-role messages.

Arize Phoenix v5.2.0 introduces a new Phoenix CLI.

$ git clone --branch arize-phoenix-v5.2.0 https://github.com/Arize-ai/phoenix.git
# already have the repo? check out this version:
$ git checkout arize-phoenix-v5.2.0

• ›Adds a Phoenix command-line interface (phoenix CLI) for interacting with Phoenix from the terminal.

Langfuse v2.85.0 adds AWS Bedrock support in the playground and evals, plus a color-coding toggle for trace tree metrics.

$ git clone --branch v2.85.0 https://github.com/langfuse/langfuse.git
# already have the repo? check out this version:
$ git checkout v2.85.0

• ›Adds AWS Bedrock support in the Playground and LLM-as-a-judge evaluations.
• ›Adds a toggle in the UI to enable or disable color coding of metrics on the trace tree.
• ›Enables annotation queues for cloud hobby-tier plans.

Langfuse v2.84.0 adds annotation queues (beta) and API key invalidation via cloud admin API.

$ git clone --branch v2.84.0 https://github.com/langfuse/langfuse.git
# already have the repo? check out this version:
$ git checkout v2.84.0

• ›Adds API key invalidation via the cloud admin API.
• ›Introduces annotation queues as a feature-flagged beta, with support for updating queue names.

Langfuse v2.83.0 adds GitLab as an authentication provider.

$ git clone --branch v2.83.0 https://github.com/langfuse/langfuse.git
# already have the repo? check out this version:
$ git checkout v2.83.0

• ›Adds GitLab as an OAuth authentication provider for self-hosted deployments.

Langfuse v2.82.0 adds tokens-per-second to the generations table and improves cost/latency rendering in the trace view.

$ git clone --branch v2.82.0 https://github.com/langfuse/langfuse.git
# already have the repo? check out this version:
$ git checkout v2.82.0

• ›Adds tokens-per-second display to the generations table, giving practitioners a quick throughput signal alongside existing latency and cost columns.
• ›Improves cost and latency rendering on the trace tree and trace preview for clearer at-a-glance performance inspection.
• ›Supports initializing environment variables via Docker Compose to streamline self-hosted deployments.

Weave v0.51.16 adds NotDiamond integration, paginated table queries, op display names, finish handlers, and async-friendly tracing.

$ git clone --branch v0.51.16 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.16

import weave

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

import weave

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

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

my_op.finish_handler = on_finish

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

Weave v0.51.14 adds paginated table queries, TableQueryStats exposure, minimized blocking during tracing, and a finish handler for ops.

$ git clone --branch v0.51.14 https://github.com/wandb/weave.git
# already have the repo? check out this version:
$ git checkout v0.51.14

• ›Exposes TableQueryStats and supports paginated table queries, enabling callers to retrieve large tables in pages rather than a single blocking fetch.
• ›Minimizes blocking calls while tracing, reducing latency impact on instrumented code paths.
• ›Adds a finish handler for ops, allowing post-execution hooks to be registered on operations.
• ›New Callout UI component added to the frontend component library.

Chroma 0.5.13 brings persistent block/sparse index caches and binary search for range filter operators.

$ git clone --branch 0.5.13 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.5.13

• ›Switches block and sparse index caches to a persistent type, improving cache durability across restarts.
• ›Accelerates gt, gte, lt, and lte metadata filter operations using binary search, reducing lookup time on large indexes.

Chroma 0.5.12 delivers 21x faster full-text queries, unified filter-operator semantics, and a new disk/memory-backed cache.

$ git clone --branch 0.5.12 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.5.12

• ›Changes the semantics of $ne, $nin, and $not_contains operators for local Chroma to align with hosted Chroma behavior.
• ›Delivers 21x faster full-text querying via internal index improvements.
• ›Adds disk- and memory-backed caching powered by Foyer 0.10, enabling larger-than-RAM working sets.
• ›Adds tenant, database, and collection IDs to distributed traces when available, improving observability.
• ›Introduces a RateLimitEnforcer abstract class for implementing rate-limiting policies.

LanceDB v0.12.0 adds hybrid search distance types, fast_search on remote tables, and embedding support on empty table creation.

$ git clone --branch v0.12.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.12.0

• ›Allows distance type (metric) to be specified during hybrid search queries.
• ›Enables fast_search on Python remote tables.
• ›Supports add_embedding on create_empty_table in the Rust client.
• ›Enables logging and full error display in the Node.js client.

LanceDB v0.11.1-beta.0 adds fast_search on Python remote tables and add_embedding support on empty table creation in Rust.

$ git clone --branch v0.11.1-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.11.1-beta.0

• ›Enables add_embedding on create_empty_table in the Rust API, allowing embedding configurations to be attached at table creation time.
• ›Supports fast_search on Python remote tables, extending the fast search capability to remote table workflows.
• ›Upgrades lance to 0.18.3, bringing underlying engine improvements.

LanceDB python-v0.14.1-beta.0 adds fast_search on remote tables and embedding support on empty table creation.

$ git clone --branch python-v0.14.1-beta.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.14.1-beta.0

• ›Enables fast_search on Python remote tables for accelerated vector search against remote LanceDB deployments.
• ›Allows add_embedding to be used on create_empty_table in the Rust client, enabling embedding configuration at table creation time before data is added.

LanceDB python-v0.14.0 adds async merge_insert, fast_search, hybrid search in SaaS, trust_remote_code for HF embeddings, and a Rust-backed remote SDK.

$ git clone --branch python-v0.14.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout python-v0.14.0

results = table.search(query_vector).fast_search().limit(10).to_list()

embeddings = get_registry().get("huggingface").create(name="trust-remote/model", trust_remote_code=True)

• ›Adds merge_insert to the async Python API, enabling upsert workflows without blocking the event loop.
• ›Adds fast_search option to vector queries for approximate nearest-neighbor searches that trade recall for speed.
• ›Adds trust_remote_code support in Hugging Face embeddings, allowing models that require remote code execution to be loaded directly.
• ›Enables explicit hybrid search query patterns in the SaaS (remote) Python SDK, reaching feature parity with the local SDK.
• ›Adds with_row_id to the Rust SDK for queries that need to surface internal row identifiers.

LanceDB v0.11.0 adds full remote SDK support in Rust and Node, fast search, async merge_insert, and hybrid search parity in SaaS.

$ git clone --branch v0.11.0 https://github.com/lancedb/lancedb.git
# already have the repo? check out this version:
$ git checkout v0.11.0

$ embeddings = get_registry().get('huggingface').create(name='org/custom-model', trust_remote_code=True)

• ›Adds with_row_id option to the Rust SDK for queries that need to retrieve internal row identifiers.
• ›Adds fast_search option to vector search, enabling approximate search without scanning the full index.
• ›Adds trust_remote_code support in Hugging Face embeddings via Python SDK, allowing custom model code to run during embedding.
• ›Adds merge_insert to the async Python API, enabling upsert workflows without blocking the event loop.
• ›Adds list_indices endpoint to the Rust remote SDK for programmatic index discovery.

Milvus 2.4.13 adds dynamic replica adjustment, sparse vector MMAP in growing segments, and a new import-jobs REST endpoint.

$ git clone --branch v2.4.13 https://github.com/milvus-io/milvus.git
# already have the repo? check out this version:
$ git checkout v2.4.13

• ›Adds a new RESTful URL to describe import jobs, enabling programmatic monitoring of bulk-import progress.
• ›Supports dynamic replica adjustment for loaded collections, letting users change replica counts without releasing and reloading the collection.
• ›Enables MMAP for sparse vectors in growing segment types, reducing memory footprint for sparse workloads.
• ›Enables load balancing across query nodes with varying memory capacities.
• ›Enables manual compaction for collections that have no indexes.

Milvus v2.3.22 adds trace ID propagation from client to server for distributed request tracing.

$ git clone --branch v2.3.22 https://github.com/milvus-io/milvus.git
# already have the repo? check out this version:
$ git checkout v2.3.22

• ›Propagates trace IDs from the client through the system, enabling end-to-end distributed tracing of requests.

Weaviate v1.27.0 adds ACORN-based HNSW filters, backup cancellation APIs, experimental read-compute scaling, dynamic RAG via gRPC, and new embedding/generative modules.

$ git clone --branch v1.27.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.27.0

• ›Adds a backup cancellation endpoint and a 'list backups in progress' endpoint, with CANCELED status now propagated across all backup API responses and a path field added to list backup responses.
• ›Adds experimental read-compute scaling via a separate querier component (exp/query) supporting vector search, property filters, and object retrieval from the LSMKV store for offloaded (FROZEN) tenants.
• ›Supports dynamic RAG syntax through the gRPC API.
• ›Supports sending Azure OpenAI deployment ID and resource name via request headers.
• ›Adds support for custom number of dimensions when using Azure OpenAI.

Composio v0.5.36 adds check_connected_accounts flag to get_tools and auth_scheme support on get_expected_params_for_user.

$ git clone --branch v0.5.36 https://github.com/ComposioHQ/composio.git
# already have the repo? check out this version:
$ git checkout v0.5.36

• ›Adds check_connected_accounts flag to get_tools to filter tools based on whether the entity has connected accounts.
• ›Adds auth_scheme parameter support on get_expected_params_for_user to specify the authentication scheme when retrieving expected auth params for a user.
• ›Adds API key and entityId support for auth handling, enabling per-entity authentication flows.

Composio v0.5.35 adds user-defined auth for action execution and custom auth data support in the JS SDK.

$ git clone --branch v0.5.35 https://github.com/ComposioHQ/composio.git
# already have the repo? check out this version:
$ git checkout v0.5.35

• ›Adds support for user-defined auth parameters during action execution in the Python SDK, enabling callers to supply custom credentials at runtime rather than relying solely on stored connections.
• ›Adds custom auth data support in the JS SDK (released as JS SDK v0.2.3), bringing parity with the Python SDK for runtime auth overrides.
• ›Makes is_secret a default argument in auth parameter definitions, simplifying how sensitive fields are declared.
• ›Adds a Cloudflare + OpenAI integration example.

Composio v0.5.34 adds getExpectedParamsForUser method across all framework integrations.

$ git clone --branch v0.5.34 https://github.com/ComposioHQ/composio.git
# already have the repo? check out this version:
$ git checkout v0.5.34

• ›Adds getExpectedParamsForUser method (and Python equivalent get_expected_params_for_user) to all framework integrations, enabling callers to retrieve the expected connection parameters for a given user.

Composio v0.5.32 adds user-defined auth params for connectors, integration ID lookup by app, and ExpectedFieldInput support

$ git clone --branch v0.5.32 https://github.com/ComposioHQ/composio.git
# already have the repo? check out this version:
$ git checkout v0.5.32

• ›Adds ExpectedFieldInput attribute and a separate method for customer expected fields, enabling more precise definition of required auth inputs when configuring connectors.
• ›Adds support for user-defined auth params when initialising connectors, giving practitioners control over custom authentication parameters at connector setup time.
• ›Adds support for specifying connected account params when initialising a connected account.
• ›Adds support for fetching integration ID using app name, simplifying programmatic lookup of integrations.
• ›Logs session ID when ingesting logs and executing an action, improving traceability across action executions.

Composio v0.5.31 adds log ingestion for local tool execution, an auth params API, and connection info in the JS SDK.

$ git clone --branch v0.5.31 https://github.com/ComposioHQ/composio.git
# already have the repo? check out this version:
$ git checkout v0.5.31

• ›Adds log ingestion for local tool execution, enabling visibility into locally run tool actions.
• ›Adds an auth params API for retrieving authentication parameters programmatically.
• ›Adds connection info support and fixes the initConnection flow in the JavaScript SDK.