The AI Toolchain — issue -375, August 31, 2024

Aider v0.53.0 adds prompt cache keepalive pings, bulk confirmation controls, and a dev-branch installer.

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

$ aider --install-main-branch

• ›Adds --cache-keepalive-pings to periodically ping the API every 5 minutes and prevent prompt cache expiration.
• ›Enables bulk accept/reject of add-URL and run-shell confirmation prompts in a single action.
• ›Adds --install-main-branch flag to upgrade directly to the latest development version of Aider.
• ›Surfaces model metadata information when running with --verbose.
• ›Extends extra_headers support to the weak model, enabling Anthropic beta features for that model tier.

Aider v0.52.0 adds interactive shell command suggestions, a new /reset command, and repo map size control.

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

$ /reset

$ aider --map-multiplier-no-files 4

• ›Adds automatic shell command suggestions after edits — offers to launch a browser, install dependencies, run DB migrations, execute the program, or run new tests.
• ›New /reset command drops all files and clears chat history in one step.
• ›New --map-multiplier-no-files flag controls the repo map size multiplier when no files are loaded in chat.
• ›Switches default OpenAI model to gpt-4o-2024-08-06.
• ›/read and /drop now expand ~ to the home directory.

Aider v0.51.0 adds Anthropic prompt caching, configurable repo-map refresh, and improved Jupyter Notebook editing.

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

$ aider --map-refresh files

• ›Adds --cache-prompts flag to enable prompt caching for Anthropic models, covering the system prompt, repo map, and /read-only files.
• ›Adds --map-refresh flag with modes always, files, manual, and auto to control how often the repo map recomputes — useful for large or monorepos.
• ›Improves editing performance on Jupyter Notebook .ipynb files.
• ›Shows which config YAML file is loaded when running with --verbose.

Aider v0.50.0 adds DeepSeek Coder support, infinite output for more models, and new chat-mode switching.

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

$ aider --deepseek

$ aider --chat-mode ask
# then inside the session:
/code refactor the authentication module to use bcrypt

• ›New --deepseek switch enables DeepSeek Coder with 8k token output.
• ›Infinite output (streaming past normal limits) now supported for DeepSeek Coder and Mistral models, in addition to Anthropic models.
• ›New --chat-mode <mode> switch lets you launch directly into ask, help, or code mode.
• ›New /code <message> command lets you request a code edit without leaving ask mode.

Aider v0.49.0 adds read-only file context, clipboard pasting, in-script slash commands, and new model shortcuts.

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

$ aider --read ../shared/schema.sql src/models.py

$ /clipboard

$ aider --message "/read ../policy.md Summarize any security policy violations in auth.py" auth.py

• ›Adds /read command and --read flag to include read-only files in chat context, including files outside the git repo.
• ›New /clipboard command pastes images or text from the clipboard directly into the chat (replaces /add-clipboard-image).
• ›Enables in-chat / commands inside scripted aider messages for automation workflows.
• ›Adds --mini flag as a shorthand to use gpt-4o-mini.
• ›Adds --attribute-commit-message-author to prefix commit messages with 'aider: ' only when aider authored the changes.

Aider v0.48.0 adds clipboard image input, subtree scoping, and unlocks repo maps for any model.

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

$ cd services/auth && aider --subtree-only

$ aider --map-tokens 1024 --model <your-model>

$ /add-clipboard-image

• ›New /add-clipboard-image command lets you paste images directly into the chat.
• ›New --subtree-only flag scopes aider to the current directory subtree, improving large and mono-repo performance.
• ›Use --map-tokens 1024 to enable repo map with any model, not just defaults.
• ›Supports Sonnet's 8k output window.

Cline v1.4.0 adds auto-approved read-only file access and sliding window context management for 200k+ token tasks.

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

• ›New 'Always allow read-only operations' setting lets Claude read files and view directories without requiring per-action approval.
• ›Implements sliding window context management to keep long-running tasks alive beyond the 200k token context limit.

Cline v1.2.0 adds Anthropic Prompt Caching support, cutting costs up to 90% and latency up to 85%.

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

• ›Supports Anthropic Prompt Caching for Claude 3.5 Sonnet and Claude 3.0 Haiku, reducing API costs up to 90% and latency up to 85%.

OpenHands 0.9.0 adds vision LLM support, a Security Analyzer, async LLM calls, and switches to EventStream Runtime by default.

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

• ›Adds vision input support for LLMs with vision capabilities, enabling image-aware agent interactions.
• ›Adds a Security Analyzer functionality for automated security review workflows.
• ›Enhances the LLM class with async support for non-blocking model calls.
• ›Implements copy_to for Runtime, allowing files to be pushed directly into the agent's runtime environment.
• ›Supports injecting additional dependencies into the OpenHands runtime Docker image at launch.

OpenHands 0.8.3 adds a UI toggle for agent selection and Dev Container support for GitHub Codespaces.

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

• ›Adds a UI toggle to enable or disable agent selection (defaults to off, hiding agent selection from end users).
• ›Adds Dev Container configuration for GitHub Codespaces, enabling one-click cloud development environments.

Zed v0.148.0 adds tool calling for OpenAI/Ollama, REPL markdown rendering, and a new 'go to declaration' editor action.

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

• ›Adds editor: go to declaration editor action for LSP-based declaration navigation.
• ›Prompt templates for inline transformation (editor and terminal) can now be overridden by placing files in ~/.config/zed/prompts/templates.
• ›The ordering of language_servers in settings now controls which server is treated as primary.
• ›Adds ctrl-alt-enter (ctrl-option-enter on macOS) keybinding for repl::RunInPlace, keeping screen position and cursor in place.
• ›Adds update_display_data support for REPL, enabling live-updating outputs.

Zed v0.147.2 adds GitHub Copilot Chat, inline terminal assistant, font fallback settings, and SSH remoting terminal support.

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

{
  "buffer_font_fallbacks": ["Noto Sans Mono", "Symbols Nerd Font"],
  "ui_font_fallbacks": ["Noto Sans"],
  "terminal": {
    "font_fallbacks": ["Noto Sans Mono"]
  }
}

• ›Adds ui_font_fallbacks, buffer_font_fallbacks, and terminal.font_fallbacks settings for font fallback configuration.
• ›Adds GitHub Copilot Chat as an AI assistant option, available in the model dropdown after signing into GitHub Copilot within Zed.
• ›Adds ctrl-enter keybind to invoke the inline assistant in the terminal, enabling natural-language generation of terminal commands.
• ›Adds support for language server tracing to the LSP log view.
• ›Adds terminal and task support to the experimental SSH remoting alpha.

langchain-prompty 0.0.3 adds a template format parameter to create_chat_prompt and fixes double-templating.

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

• ›Adds a template format parameter to create_chat_prompt in langchain_prompty, letting callers explicitly control which templating engine is applied to the prompt.

langchain-ollama 0.1.2 adds base_url, headers, and auth parameters plus standard tracing params for LLMs.

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

• ›Adds base_url, headers, and auth parameters to the Ollama integration, enabling connections to custom or authenticated Ollama endpoints.
• ›Implements standard tracing parameters for LLMs across the Ollama integration, aligning tracing output with the rest of the LangChain ecosystem.

LangChain Community 0.2.14 adds relevance score support to PineconeHybridSearchRetriever.

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

• ›Adds relevance score output to PineconeHybridSearchRetriever results.

langchain-community 0.2.13 adds MMR to Neo4j vector, async support in PebbloRetrievalQA, Nebula Chat model, TiDB vector index, and more.

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

• ›Adds where argument support to ChromaDB delete() for filtered document deletion.
• ›Adds args_schema to SearxSearchResults tool for structured argument validation.
• ›Adds metadata filter support to CassandraGraphVectorStore.
• ›Adds score function for similarity_score_threshold in OpenSearch vector store.
• ›Adds MMR (Maximal Marginal Relevance) retrieval support to Neo4j vector store.

langchain-core 0.2.35 adds nested subgraph rendering in Mermaid, chunk separator control in merge_message_runs, and recursive additionalProperties in strict OpenAI functions.

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

from langchain_core.messages.utils import merge_message_runs

merged = merge_message_runs(messages, chunk_separator="\n")

• ›Adds chunk_separator option to merge_message_runs to control how message chunks are joined when merging.
• ›Supports drawing nested subgraphs in draw_mermaid, enabling richer visual graph representations.
• ›Adds additionalProperties recursively to OpenAI function schemas when strict mode is enabled.
• ›Adds _api.rename_parameter utility to support renaming parameters in functions without breaking callers.

langchain-core 0.2.34 adds a LangSmith document loader and allows bound models as token counters in trim_messages.

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

• ›Adds a LangSmith document loader to langchain-core for loading documents directly from LangSmith.
• ›Allows bound models (e.g. models with pre-configured parameters) to be passed as the token_counter argument in trim_messages, expanding its flexibility.
• ›Supports OpenAI-format dicts as message inputs, broadening interoperability with OAI-style message representations.
• ›Adds @beta decorator to previously unmarked GraphVectorStore extension classes in core and community.

LangChain Community 0.2.12 adds FireCrawl LLM extraction, financialdatasets.ai stock tools, SharePoint extended metadata, and ZhipuAI structured output.

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

• ›Adds dimension parameter to ZhipuAIEmbeddings for controlling embedding output size.
• ›Adds bind_tools and with_structured_output methods to ChatZhipuAI for structured LLM interactions.
• ›Adds llm-extraction option to the FireCrawl Document Loader for AI-powered content extraction during crawls.
• ›Adds stock market tools from financialdatasets.ai as new community tools.
• ›Adds kwargs support to CassandraGraphVectorStore for extended configuration.

LangChain 0.2.13 adds DocumentIndex support in the index API and strict tool calling for OpenAI models.

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

• ›Adds support for DocumentIndex in the index API, enabling document indexing workflows via the new integration.
• ›Enables strict tool calling for OpenAI models via core and openai packages.
• ›Changes default prompt-pulling behavior to use the LangSmith SDK first, falling back to LangChain Hub.

langchain-core 0.2.30 adds a secrets-from-env factory and from_env utility for cleaner credential wiring.

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

• ›Adds from_env utility function for looking up secrets and configuration values directly from environment variables.
• ›Adds standard tracing parameters for retrievers, expanding LangSmith observability to retriever components.
• ›Autodetects more LangSmith (ls) parameters, reducing manual tracing configuration.

langchain-openai 0.1.21 adds strict tool calling and JSON Schema support for structured output.

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

• ›Adds json_schema support to ChatOpenAI.with_structured_output, enabling JSON Schema-based structured output responses.
• ›Enables strict tool calling mode for ChatOpenAI, giving tighter control over tool invocation behavior.

langchain-mongodb gains Hybrid and Full-Text Search Retrievers plus improved search index commands.

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

• ›Adds Hybrid Search and Full-Text Search Retrievers for MongoDB Atlas, enabling combined vector + keyword and pure keyword retrieval workflows.
• ›Improves search index management commands for MongoDB Atlas vector stores.

langchain-openai 0.1.21rc2 adds JSON Schema support in with_structured_output and strict tool calling mode.

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

• ›Adds json_schema support to ChatOpenAI.with_structured_output, enabling structured output via OpenAI's JSON Schema response format.
• ›Enables strict tool calling mode for ChatOpenAI, allowing tools to be invoked with OpenAI's strict parameter enforcement.

langchain-core 0.2.29 adds DocumentIndex abstraction, index API support, and strict tool calling for OpenAI.

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

• ›Introduces DocumentIndex abstraction, a new interface for document storage and retrieval backends.
• ›Adds support for DocumentIndex in the index API, enabling use of the new abstraction with existing indexing workflows.
• ›Enables strict tool calling for OpenAI-backed language models.
• ›Adds disable_streaming support to the base language model interface.
• ›Sets context propagation in RunnableSequence and RunnableParallel for improved tracing and context handling.

LangChain OpenAI 0.1.21rc1 enables strict tool calling for OpenAI models.

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

• ›Enables strict tool calling mode for OpenAI integrations.

langchain-core 0.2.29rc1 adds strict tool calling support and a new DocumentIndex abstraction for the index API.

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

• ›Introduces DocumentIndex abstraction, a new base class for document index integrations.
• ›Adds DocumentIndex support to the index API, enabling document indexing workflows against the new abstraction.
• ›Enables strict tool calling mode for OpenAI tool/function calls.

langchain-community 0.2.11 adds new integrations, tools support, and retriever capabilities across a broad set of providers.

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

from langchain_community.retrievers import WebResearchRetriever

retriever = WebResearchRetriever.from_llm(
    llm=llm,
    search=search,
    allow_dangerous_requests=True
)

from langchain_community.document_loaders.firecrawl import FireCrawlLoader

loader = FireCrawlLoader(
    url="https://example.com",
    api_url="https://my-firecrawl-instance.internal"
)
docs = loader.load()

from langchain_community.document_compressors.flashrank_rerank import FlashrankRerank

reranker = FlashrankRerank(score_threshold=0.5)
filtered_docs = reranker.compress_documents(documents=docs, query="my query")

• ›Adds allow_dangerous_requests parameter to WebResearchRetriever.from_llm constructor to explicitly gate dangerous HTTP requests.
• ›Replaces filters argument with filter in DatabricksVectorSearch — callers must update their keyword argument.
• ›Adds auth passthrough parameter to Ollama LLM requests via langchain_community Ollama integration.
• ›Adds score_threshold parameter to flashrank_rerank.py for controlling reranking cutoff.
• ›Adds api_url parameter to document_loaders.firecrawl to support specifying a custom Firecrawl API endpoint.

langchain-experimental 0.0.64 adds a Relik graph transformer and per-call config support for graph document conversion.

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

• ›Adds RelikGraphTransformer for extracting graph structures using the Relik model.
• ›Adds config parameter to convert_to_graph_documents to pass runtime configuration per call.
• ›Adds ImagePromptTemplate compatibility to OllamaFunctions for multimodal prompt support.

langchain 0.2.12 adds Bedrock Converse and Ollama support to init_chat_model(), plus a HANA Cloud self-query retriever.

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

• ›Adds ChatBedrockConverse support to init_chat_model(), allowing Bedrock Converse models to be initialised via the unified model-factory function.
• ›Adds ChatOllama support to init_chat_model(), importing from langchain-ollama with a fallback to langchain-community.
• ›Adds a self-query retriever for HANA Cloud Vector Engine in langchain-community, enabling structured metadata filtering against SAP HANA Cloud.

langchain-ollama 0.1.1 adds seed, base_url, and image-input support to ChatOllama.

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

from langchain_ollama import ChatOllama

llm = ChatOllama(model="llama3", seed=42)
response = llm.invoke("Explain prompt injection in one sentence.")
print(response.content)

from langchain_ollama import ChatOllama

llm = ChatOllama(model="llama3", base_url="http://ollama-host:11434")
response = llm.invoke("Summarize this alert.")
print(response.content)

• ›Adds seed parameter to ChatOllama for reproducible, deterministic LLM outputs.
• ›Adds base_url parameter to ChatOllama, enabling connections to non-default or remote Ollama instances.
• ›Supports image inputs for multimodal use cases in langchain_ollama.
• ›Adds TypedDict to tool schema conversion support for Ollama integrations.

LangGraph SDK 0.1.30 adds state-value filtering for thread search and makes runs.join() return final thread state.

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

threads = await client.threads.search(values={"topic": "billing", "status": "open"})

final_state = await client.runs.join(thread_id, run_id)
print(final_state)

• ›Adds values parameter to client.threads.search() for filtering threads by their state values.
• ›Changes client.runs.join() to return a dictionary containing the final thread state instead of None.
• ›Introduces Json type as a replacement for the Metadata type to better reflect its semantic purpose.

LangGraph Checkpoint 1.0.7 adds parent checkpoint references and pending-send tracking across checkpoint operations.

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

• ›Adds parents field to CheckpointMetadata, mapping checkpoint namespace to checkpoint ID for relationship tracking between checkpoints.
• ›Adds pending-send tracking in InMemorySaver: get_tuple now includes pending_sends from parent checkpoints, and list gains improved namespace filtering.

LangGraph CLI 0.1.52 adds Node.js/LangGraphJS deployment support with dedicated Docker configuration.

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

{
  "node_version": "20",
  "graphs": {
    "my_graph": "./src/graph.ts:graph"
  }
}

• ›Adds node_version field to the LangGraph config TypedDict, enabling Node.js (LangGraphJS) project deployments alongside existing Python support.
• ›Adds node_config_to_docker function to generate Docker configurations for Node.js projects, automatically selecting the langchain/langgraphjs-api base image.
• ›Adds validation for the node_version config field (currently enforces version "20") to catch misconfigured Node.js projects early.
• ›Updates build, prepare, and deployment CLI commands to operate correctly against both Python and Node.js environments.

LangGraph Postgres checkpointer now accepts connection pools for high-concurrency deployments.

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

from psycopg_pool import ConnectionPool
from langgraph.checkpoint.postgres import PostgresSaver

pool = ConnectionPool("postgresql://user:password@localhost/db", min_size=2, max_size=10)
saver = PostgresSaver(pool)

from psycopg_pool import AsyncConnectionPool
from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver

pool = AsyncConnectionPool("postgresql://user:password@localhost/db", min_size=2, max_size=10)
saver = AsyncPostgresSaver(pool)

• ›Adds ConnectionPool support to PostgresSaver, enabling psycopg connection pool usage alongside direct connections for high-concurrency scenarios.
• ›Adds AsyncConnectionPool support to AsyncPostgresSaver for async workflows requiring pooled database connections.
• ›Enhances list() and alist() methods to include pending writes in returned checkpoint tuples.

LangGraph SDK 0.1.29 adds disconnect/completion lifecycle controls and a new join_stream() method for live run output.

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

async for chunk in client.runs.join_stream(thread_id, run_id):
    print(chunk)

async for chunk in client.runs.stream(
    thread_id,
    assistant_id,
    input=input_data,
    on_disconnect="cancel",
    on_completion="delete",
):
    print(chunk)

run = await client.runs.create(
    thread_id,
    assistant_id,
    input=input_data,
    on_completion="keep",
)

• ›Adds on_disconnect parameter to stream() and wait() — set to "cancel" or "continue" to control what happens to a run when the client disconnects.
• ›Adds on_completion parameter to stream(), create(), and wait() — set to "delete" or "keep" to control resource cleanup after a run finishes.
• ›Adds join_stream() method to attach to an already-running run and receive its real-time output without buffering prior output.
• ›Adds DisconnectMode and OnCompletionBehavior types for structured lifecycle control in typed clients.

LangGraph 0.2.13 adds runtime-only managed values and reimplements Context to skip unnecessary serialization.

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

from langgraph.managed.base import ManagedValue

class MyRuntimeValue(ManagedValue, runtime=True):
    ...

• ›Adds a runtime flag to ManagedValue that marks values as created at runtime and excluded from serialization/deserialization.
• ›Adds replace_runtime_values and replace_runtime_placeholders methods to ManagedValueMapping for safe handling of runtime placeholders during graph serialization.
• ›Reimplements Context as a managed value (langgraph.managed.context.ContextManagedValue) with runtime=True, integrating it with the managed value system instead of the channel system.

LangGraph CLI 0.1.51 adds Redis 6 to Docker Compose for caching and message queuing.

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

• ›Adds Redis 6 as a managed Docker Compose service with health-check gating, so langgraph-api only starts after Redis is healthy.
• ›Injects REDIS_URI environment variable (redis://langgraph-redis:6379) automatically into the langgraph-api service.

LangGraph Checkpoint 1.0.4 adds error-write support, an ERROR constant, and exception serialization in JsonPlusSerializer.

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

from langgraph.checkpoint.serde.types import ERROR

# In a custom checkpointer's put_writes, tag a failed write with the ERROR sentinel
writes = [(ERROR, exception_value)]
await checkpointer.put_writes(config, writes, task_id)

• ›Adds ERROR = "__error__" constant in langgraph.checkpoint.serde.types to represent error types in checkpoint writes.
• ›Supports special write types including error handling via WRITES_IDX_MAP in InMemorySaver.put_writes.
• ›Enables JsonPlusSerializer to serialize BaseException objects by encoding them using their constructor arguments.
• ›Includes pending writes in checkpoint list output from InMemorySaver.

LangGraph 0.2.10 adds error and interrupt fields to debug task result payloads for richer execution tracing.

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

for chunk in graph.stream(inputs, stream_mode="debug"):
    if chunk["type"] == "task_result":
        payload = chunk["payload"]
        if payload["error"]:
            print("Task error:", payload["error"])
        if payload["interrupts"]:
            print("Interrupts:", payload["interrupts"])

• ›Adds error: Optional[str] and interrupts: list[dict] fields to TaskResultPayload for capturing task-level errors and interrupts in debug output.
• ›Enhances put_writes on PregelLoop to automatically stream updates and debug information without manual wiring.
• ›Adds stream_keys as a class attribute on PregelLoop for explicit management of streaming outputs.
• ›Updates map_debug_task_results to accept task-writes pairs and support both string and sequence stream key formats.

LangGraph SDK 0.1.28 adds custom HTTP headers support and checkpoint namespace field for state configs.

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

from langgraph_sdk import get_client

client = get_client(
    url="https://your-langgraph-endpoint",
    headers={"x-tenant-id": "acme-corp", "x-trace-id": "abc123"},
)

state = await client.threads.get_state(
    thread_id="<thread_id>",
    checkpoint_id="<checkpoint_id>",
    checkpoint_ns="pipeline-a",
)

• ›Adds a headers parameter to get_client for injecting custom HTTP headers into all API requests, with validation blocking reserved headers like x-api-key.
• ›Adds a checkpoint_ns field to state configurations in get_state and create for namespace-scoped checkpoint lookups.

LangGraph 0.2.7 adds SharedValue and a pluggable store system for persisting state across graph nodes.

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

from langgraph.graph.state import StateGraph
from langgraph.managed.shared_value import SharedValue
from langgraph.store.memory import MemoryStore

store = MemoryStore()
graph = StateGraph(...)
# SharedValue field is accessible and writable by all nodes
graph.add_node("node_a", node_a_fn)
graph.add_node("node_b", node_b_fn)
app = graph.compile(store=store)

from langgraph.store.memory import MemoryStore
from langgraph.store.batch import AsyncBatchedStore

batched_store = AsyncBatchedStore(MemoryStore())
app = graph.compile(store=batched_store)

from langgraph.managed.base import is_writable_managed_value, is_readonly_managed_value

if is_writable_managed_value(my_value):
    await my_value.aupdate(new_data)
elif is_readonly_managed_value(my_value):
    print("This value cannot be updated")

• ›New SharedValue class enables shared, writable state across graph nodes with optional scoping by configuration.
• ›New WritableManagedValue abstract class extends the managed values system with update() and aupdate() methods for sync/async mutations.
• ›New store parameter on StateGraph.compile() wires a persistent storage backend into the graph.
• ›New BaseStore abstract class defines a standard interface (list/update, sync and async) for pluggable storage engines.
• ›New MemoryStore provides a ready-to-use in-memory implementation of BaseStore.

LangGraph 0.2.6 adds structured graph interrupts with timing context and a new NodeInterrupt exception for in-node signaling.

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

from langgraph.errors import NodeInterrupt

def review_node(state):
    if state["needs_approval"]:
        raise NodeInterrupt("Waiting for human approval before proceeding")
    return state

from langgraph.errors import GraphInterrupt

try:
    result = graph.invoke(inputs)
except GraphInterrupt as e:
    for interrupt in e.interrupts:
        print(f"Interrupted {interrupt.when}: {interrupt.value}")

• ›New Interrupt dataclass captures structured interruption events with a when field ("before", "during", "after") and an optional value.
• ›New NodeInterrupt exception lets node logic explicitly signal a mid-execution interrupt without raising a generic error.
• ›Enhanced GraphInterrupt now stores a list of Interrupt objects, giving full context on when and how many interrupts occurred.
• ›Adds interrupts field to PregelTask for per-task interrupt visibility useful in debugging and flow control.
• ›Adds CONFIG_KEY_TASK_ID constant to track task identifiers through the configuration system.

LangGraph 0.2.5 adds task-level error tracking in state snapshots and a new ERROR constant for consistent failure visibility.

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

snapshot = await graph.aget_state(config)
for task in snapshot.tasks:
    if task.error is not None:
        print(f"Task {task.id} failed with: {task.error}")

• ›Adds ERROR = "__error__" constant (reserved key) for consistent error tracking and propagation across graph execution.
• ›Enhances StateSnapshot with a new tasks field that surfaces task-level error details in state history.
• ›Introduces enhanced PregelTask class with id and optional error fields to uniquely identify tasks and capture exceptions.
• ›Adds tasks_w_writes debug function to associate tasks with their writes and any errors for richer checkpoint debug output.
• ›Extends get_state / aget_state on Pregel to include proper step numbers and task error information in returned snapshots.

JsonPlusSerializer gains native support for pathlib, regex, decimal, deque, IP address, and time types.

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

• ›Supports serialization of pathlib.Path, re.Pattern, decimal.Decimal, deque, IPv4/IPv6 address types, date, time, and ZoneInfo in JsonPlusSerializer.
• ›Deserialization now returns None gracefully when a module or attribute is missing, instead of raising an exception.

LangGraph PostgreSQL checkpointer gains versioned schema migrations and JSON+Plus metadata serialization.

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

from langgraph.checkpoint.postgres import PostgresSaver

with PostgresSaver.from_conn_string("postgresql://user:pass@localhost/db") as saver:
    saver.setup()  # applies all pending MIGRATIONS instead of recreating tables

from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver

async with AsyncPostgresSaver.from_conn_string("postgresql://user:pass@localhost/db") as saver:
    await saver.setup()  # applies MIGRATIONS for the async variant

• ›Adds versioned database migrations (MIGRATIONS list) for both PostgresSaver and AsyncPostgresSaver, replacing one-shot static table creation.
• ›Introduces JsonPlusSerializer-backed _load_metadata and _dump_metadata methods for consistent, richer metadata serialization across sync and async savers.

LangGraph 0.2 ships dedicated checkpointer libraries for SQLite and Postgres, including the previously cloud-only PostgresSaver.

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

from langgraph.checkpoint.sqlite import SqliteSaver

with SqliteSaver.from_conn_string("./local_state.db") as checkpointer:
    graph = app.compile(checkpointer=checkpointer)
    result = graph.invoke(
        {"messages": ["Hello"]},
        config={"configurable": {"thread_id": "dev-session-1"}}
    )

• ›New langgraph-checkpoint package exposes BaseCheckpointSaver, SerializationProtocol, and MemorySaver as a standalone base library.
• ›New langgraph-checkpoint-sqlite package provides SqliteSaver / AsyncSqliteSaver for local and experimental workflows.
• ›New langgraph-checkpoint-postgres package open-sources the production-grade PostgresSaver previously available only in LangGraph Cloud.
• ›New new_versions parameter in BaseCheckpointSaver.put enables further optimization of custom checkpointer implementations.
• ›Graph stream output now includes outputs from all nodes, including nodes that return no state writes (previously silent nodes were omitted).

LangGraph checkpoint 1.0.1 adds binary serialization, channel-version API, and context-manager support for MemorySaver.

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

from langgraph.checkpoint.memory import MemorySaver

with MemorySaver() as saver:
    # saver is fully initialised; resources released on exit
    checkpoints = list(saver.list(config))

from langgraph.checkpoint.serde.jsonplus import JsonPlusSerializer

serde = JsonPlusSerializer()
type_tag, encoded = serde.dumps_typed(b"\x89PNG\r\n")
restored = serde.loads_typed((type_tag, encoded))
assert isinstance(restored, bytes)

• ›Adds bytes and bytearray serialization support to JsonPlusSerializer, enabling binary data in checkpointed state.
• ›Introduces ChannelVersions type alias (dict[str, Union[str, int, float]]) for type-safe channel version handling.
• ›Extends BaseCheckpointSaver.put and aput with a new new_versions: ChannelVersions parameter exposing channel version info at write time.
• ›Implements sync and async context manager interfaces (__enter__/__exit__/__aenter__/__aexit__) on MemorySaver for explicit resource management.

LangGraph SDK 0.1.27 adds optional URL client init, ASGI transport support, thread copy, and assistant if_exists dedup control.

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

from langgraph_sdk import get_client

client = get_client()  # url is now optional

assistant = await client.assistants.create(
    graph_id="my_graph",
    config={"configurable": {"model": "gpt-4o"}},
    if_exists="return_existing",
)

new_thread = await client.threads.copy(thread_id="<thread_id>")

• ›Makes the url parameter optional in get_client, with intelligent defaults so local dev requires no explicit URL.
• ›Adds ASGI transport support in get_client with correct root path configuration.
• ›Adds if_exists parameter to AssistantsAPI.create for controlling behavior on duplicate assistant creation.
• ›Adds a new ThreadsAPI.copy method for duplicating existing threads.
• ›Makes GraphSchema fields (input_schema, state_schema, config_schema) optional for better TypeScript interoperability.

Letta 0.3.22 adds templated system prompts, in-session system prompt editing, and a core memory size flag to the CLI and Python client.

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

$ memgpt run --core-memory-limit 6000 --persona <persona_name>

• ›Adds --system flag to memgpt run to specify a custom system prompt when creating a new agent.
• ›Adds --core-memory-limit flag to memgpt run to override the default core memory size limit (applies to both human and persona sections) for a new agent.
• ›Adds /systemswap CLI command to replace the system prompt of an already-running agent mid-session.
• ›Adds system_prompt= keyword argument to client.create_agent() in the Python client for programmatic system prompt customization.
• ›Supports f-string-style templated system prompts using the {CORE_MEMORY} placeholder, letting practitioners reposition the dynamic core memory block anywhere in the prompt.

LlamaIndex v0.10.59 adds event-driven Workflows, LongRAG pack, FalkorDB graph store, GitLab reader, and function-calling for Ollama.

$ git clone --branch v0.10.59 https://github.com/run-llama/llama_index.git
# already have the repo? check out this version:
$ git checkout v0.10.59

from llama_index.packs.longrag import LongRAGPack

pack = LongRAGPack(documents=documents, llm=llm)
response = pack.run("What are the key findings in this report?")
print(response)

• ›Introduces Workflow class in llama-index-core for event-driven orchestration of LlamaIndex pipelines.
• ›Adds llama-index-packs-longrag [0.1.0] — a new LlamaPack implementing the LongRAG retrieval pattern.
• ›Adds llama-index-graph-stores-falkordb [0.1.5] with FalkorDBPropertyGraphStore for property graph storage via FalkorDB.
• ›Adds llama-index-readers-gitlab [0.1.0] — a new GitLab reader integration for ingesting GitLab content.
• ›Adds llama-index-postprocessor-tei-rerank [0.1.0] — re-ranking support via Text Embedding Interface.

AutoGen v0.2.34 adds async nested chats, a global silent param, Azure AI Inference integration, and last_speaker tracking in GroupChat.

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

agent = ConversableAgent(
    name="assistant",
    silent=True,
    llm_config={"config_list": config_list},
)

result = await initiator.a_initiate_chats(chat_queue)

• ›Adds silent global parameter to ConversableAgent to suppress output across all agents from a single setting.
• ›Supports async nested chats, enabling non-blocking multi-agent conversation flows.
• ›Adds last_speaker attribute to GroupChatManager for tracking which agent spoke last in a group chat.
• ›Introduces AutoGen.AzureAIInference package (.NET) for Azure AI Inference model support.
• ›Adds DotnetInteractiveKernelBuilder to the AutoGen.DotnetInteractive package (.NET).

Semantic Kernel 1.17.2 adds Azure CosmosDB MongoDB and NoSQL vector store connectors, server-variable OpenAPI support, and agent chat improvements.

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

• ›Adds Azure CosmosDB for MongoDB connector implementing the new vector memory store design (Microsoft.SemanticKernel.Connectors.AzureCosmosDBMongoDB).
• ›Adds Azure CosmosDB for NoSQL connector implementing the new vector memory store design (Microsoft.SemanticKernel.Connectors.AzureCosmosDBNoSQL).
• ›Allows JsonSerializerOptions and user-agent string to be passed through vector store options down to the underlying client.
• ›Adds support for OpenAPI descriptions that include server variables, enabling dynamic base-URL resolution at runtime.
• ›Adds OpenAPI customization hooks for fine-grained control over how OpenAPI operations are mapped to kernel functions.

Semantic Kernel Python 1.7.0 adds instrumentation to kernel functions with logging, tracing, and Application Insights monitoring.

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

• ›Adds instrumentation (logs and traces) to kernel functions, with a sample application for monitoring via Application Insights.

Semantic Kernel Python 1.6.0 adds agent group chat and chat reset capabilities.

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

• ›Introduces agent group chat functionality, enabling multiple agents to participate in a shared conversation.
• ›Introduces agent chat reset functionality, allowing an agent chat session to be cleared and restarted.

Semantic Kernel .NET Agents gain a ChatHistory Reducer Pattern for managing conversation history.

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

• ›Introduces the ChatHistory Reducer Pattern for .NET Agents, enabling controlled reduction of chat history passed to agents during multi-turn conversations.

Semantic Kernel dotnet-1.17.0 adds VectorStore abstractions with 5 sample implementations and an AI Model Router demo.

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

• ›Adds VectorStore abstractions and 5 sample implementations, enabling pluggable vector storage backends for retrieval-augmented workflows.
• ›Moves VectorStore dependency-injection extensions to the core namespace, making them available without extra package references.
• ›Adds an AI Model Router demo showing how to route prompts across multiple AI models within the same Semantic Kernel pipeline.
• ›Adds metadata identification of assistant code-interpreter responses in the .NET Agents framework, surfacing interpreter output distinctly from chat completions.

Semantic Kernel Python 1.5.0 adds new memory stores and vector store data models including a Pandas-backed store.

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

• ›Adds new memory stores and collections, including a Pandas-backed memory store and new vector store data model support.

Semantic Kernel Python 1.4.0 adds Google AI, Vertex AI, Mistral AI embeddings, OpenAI Assistant Agent, and OpenTelemetry support.

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

from semantic_kernel.connectors.ai.google_ai import GoogleAIChatCompletion

chat_service = GoogleAIChatCompletion(
    gemini_model_id="gemini-1.5-pro",
    api_key="<your-google-ai-api-key>"
)

• ›Adds OpenTelemetry integration for distributed tracing and observability within Semantic Kernel Python workflows.
• ›Adds a Google AI connector with function-calling support, enabling Gemini models as chat completion backends.
• ›Adds a Vertex AI connector with function-calling support for Google Cloud-hosted model endpoints.
• ›Introduces a non-chat, non-streaming OpenAIAssistantAgent class for stateful assistant interactions, including samples and tests.
• ›Adds a Mistral AI embedding connector, expanding vector/embedding generation options beyond OpenAI.

KoboldCpp v1.73.1 adds IPv6 dual-stack support, macOS ARM binaries, and a new --prompt pure CLI mode.

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

$ ./koboldcpp --model mymodel.gguf --prompt "Summarize the risks of prompt injection" --promptlimit 200

$ ./koboldcpp --model mymodel.gguf --prompt "Once upon a time" --promptlimit 100 --benchmark

• ›Adds --prompt flag for pure CLI mode: runs a single prompt entirely from the command line, suppressing all other console output and piping the response to stdout.
• ›Adds --promptlimit flag to control output length when using --prompt CLI mode.
• ›Combines --prompt and --promptlimit with --benchmark to enable benchmarking with a custom prompt and capturing the response.
• ›--multiuser now defaults to true; set --multiuser 0 to disable multi-user mode.
• ›Adds dual-stack IPv6 network support, allowing a single KoboldCpp instance to serve both IPv4 and IPv6 addresses automatically on the same port.

KoboldCpp v1.72 adds Vulkan-accelerated Stable Diffusion image generation and Gemma2 2B support.

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

• ›Adds GPU-accelerated Stable Diffusion image generation on Vulkan backends.
• ›GPU layers now defaults to -1 in GUI mode, preserving existing layer counts instead of overwriting them, with predicted layer count shown as an overlay label.
• ›Auto GPU layer estimation now accounts for loaded image and Whisper models when calculating VRAM headroom.
• ›Adds Gemma2 2B support via upstream merge.
• ›Kobold Lite now supports SSE streaming over the OpenAI API, enabling use with alternative backends.

LocalAI v2.20.0 adds FLUX-1 image generation, OpenAI strict mode, multi-cluster P2P networking, and a global community explorer.

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

$ curl http://localhost:8080/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "my-model",
    "messages": [{"role": "user", "content": "Return info about a user"}],
    "response_format": {
      "type": "json_schema",
      "json_schema": {
        "name": "user",
        "schema": {"type": "object", "properties": {"name": {"type": "string"}, "age": {"type": "integer"}}, "required": ["name", "age"]}
      }
    },
    "strict": true
  }'

• ›Adds strict: true to API call payloads to enforce BNF-grammar-backed JSON outputs, matching OpenAI's Structured Outputs spec; when format_type is set to json_schema, BNF grammars are auto-generated from the schema.
• ›Adds LOCALAI_DISABLE_GALLERY_ENDPOINT environment variable to disable the gallery endpoint and its UI routes.
• ›Adds LOCALAI_P2P_NETWORK_ID environment variable (set to a shared UUID) to run multiple logically separated P2P clusters on the same network using the same token.
• ›Adds LOCALAI_TARGET_WORKER environment variable to target a specific worker in federated mode.
• ›Adds LOCALAI_RANDOM_WORKER environment variable to disable the new default load-balancing behavior across P2P workers.

textgen v1.13 adds Llama 3.1 support, manual context-length entry, and improved model download progress.

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

• ›Makes compress_pos_emb, n_ctx, max_seq_len, and truncation_length editable number fields instead of sliders, allowing precise manual entry of context lengths.
• ›Adds Llama 3.1 support via llama-cpp-python 0.2.85 bump, including better handling of the Llama 3.1 Jinja2 template (optional 'tools' headers now suppressed).
• ›Model downloader progress bar now shows filename, file size, and download speed per file.

vLLM v0.5.4 adds new models, W4A8 quantization, guided decoding for offline LLM, ZeroMQ-based server split, and TPU/Intel parallelism.

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

• ›Adds support for guided decoding for offline LLM inference.
• ›Separates the OpenAI server's HTTP request handling from the model inference loop using zeromq, delivering a 20% speedup in time-to-first-token and 2x improvement in inter-token latency.
• ›Adds W4A8 quantization support.
• ›Adds support for reading bitsandbytes (bnb) pre-quantized models.
• ›Tunes FP8 and INT8 kernels for Ada Lovelace and SM75 T4 GPUs.

Ollama v0.3.7 adds Hermes 3, Phi 3.5, and SmolLM models plus CUDA 12 support for up to 10% GPU performance gains.

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

$ ollama run hermes3

• ›Adds Hermes 3 (Nous Research flagship LLM with tool-calling support) via ollama run hermes3.
• ›Adds Phi 3.5, a 3.8B-parameter lightweight model competitive with larger models.
• ›Adds SmolLM family of small models at 135M, 360M, and 1.7B parameters trained on a new high-quality dataset.
• ›Adds CUDA 12 support, improving performance by up to 10% on newer NVIDIA GPUs.
• ›Improves throughput of ollama pull and ollama push on slower network connections.

Ollama v0.3.6 adds Phi-3 Safetensors import, faster GGUF importing, and progress feedback for ollama create.

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

• ›Supports importing Phi-3 models from Safetensors via ollama create.
• ›Shows progress information during GGUF file imports in ollama create.
• ›Faster GGUF file importing by minimizing file copies.

Ollama v0.3.4 adds a batch embedding API with normalization and metrics, plus three new multilingual embedding models.

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

$ curl http://localhost:11434/api/embed -d '{"model": "bge-m3", "input": ["Why is the sky blue?", "Why is the grass green?"]}'

$ curl http://localhost:11434/api/embed -d '{"model": "bge-large", "input": ["Some long document..."], "truncate": false}'

• ›New /api/embed endpoint supports batch embedding generation — submit multiple documents in a single request.
• ›Normalized embeddings now returned by default from /api/embed, improving similarity search accuracy.
• ›New truncate parameter on /api/embed lets callers enforce strict input-length control.
• ›Embedding API responses now include load_duration, total_duration, and prompt_eval_count performance metrics.
• ›Adds BGE-M3, a multilingual multi-granularity large embedding model from BAAI.

Ollama v0.3.3 adds timing and token-count metrics to both native and OpenAI-compatible embedding APIs.

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

$ curl http://localhost:11434/api/embed -d '{"model": "nomic-embed-text", "input": "Why is the sky blue?"}' | jq '{total_duration, load_duration, prompt_eval_count}'

$ curl http://localhost:11434/v1/embeddings -H 'Content-Type: application/json' -d '{"model": "nomic-embed-text", "input": "Why is the sky blue?"}' | jq '.usage'

• ›Adds total_duration, load_duration, and prompt_eval_count statistics to the /api/embed response.
• ›Adds usage metrics to the /v1/embeddings OpenAI compatibility endpoint.

Arize Phoenix v4.31.0 adds a gallery view with expandable images for vision trace data.

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

• ›Adds an image gallery view in the UI for vision traces, with support for expanding individual images.

Arize Phoenix v4.30.0 adds a new project onboarding experience.

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

• ›Introduces a new project onboarding flow to guide users through initial project setup.

Phoenix v4.29.0 adds Experiments API to OpenAPI schema and a delete mutation for system API keys.

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

• ›Adds Experiments API endpoints to the OpenAPI schema, making experiment operations formally documented and client-generatable.
• ›Adds a deleteSystemApiKey GraphQL mutation for removing system API keys.

Phoenix 4.28.0 adds a UI modal for creating users and a refreshed login screen.

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

• ›Adds a 'Create User' modal to the UI for managing user accounts directly from the interface.
• ›Refreshed login screen with improved visual design.

Phoenix v4.27.0 adds list_experiments client method, clipboard copy for experiment IDs, and onboarding demo projects.

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

import phoenix as px

client = px.Client()
experiments = client.list_experiments()

• ›Adds list_experiments client method to programmatically retrieve experiments from the Phoenix client.
• ›Adds a flag to force fixture ingestion on existing databases (in addition to limiting fixture loading to new DBs only).
• ›Adds a minimal login page for auth-enabled deployments.
• ›Enables copying experiment IDs to the clipboard directly from the experiments UI.
• ›Introduces onboarding demo projects to help new users get started quickly.

Phoenix v4.26.0 adds login/logout routes and a createUser mutation for authentication support.

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

• ›Adds login and logout routes and a createUser mutation to support user authentication workflows.

Phoenix v4.25.0 adds system API keys with expiry support, a new phoenix.otel package, and a UI for managing system keys.

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

• ›New phoenix.otel package provides a dedicated OpenTelemetry integration layer for Phoenix.
• ›Introduces system API key creation with optional expiry support, manageable via a new system API keys UI.

Phoenix 4.24.0 adds concurrency control for experiments and separates user vs. system API key resolvers.

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

run_experiment(dataset, task=my_task, concurrency=10)

evaluate_experiment(experiment, evaluators=[my_evaluator], concurrency=5)

• ›Adds concurrency parameter to run_experiment and evaluate_experiment to control parallel execution of experiments.
• ›Adds user/system API key resolvers, separating user-scoped and system-scoped key management.
• ›Adds user role support in auth, excluding system accounts from user-facing lists.

arize-phoenix-evals v0.15.0 exposes configuration for the initial rate limit on LLM eval calls.

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

• ›Exposes configuration for the initial rate limit, allowing practitioners to tune request pacing from the start of an eval run.

Phoenix v4.23.0 adds authentication controls with a settings page and users table in the UI.

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

• ›Adds a Settings page to the UI exposing the auth_enabled flag for managing authentication configuration.
• ›Adds a user GraphQL query to retrieve user information via the Phoenix GQL API.
• ›Adds a Users table within the Settings page to view and manage user accounts.

Phoenix v4.22.0 adds annotation filter actions to span and trace tables in the UI.

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

• ›Adds annotation filter actions to span and trace tables, enabling users to filter table views by annotation values directly from the UI.

Phoenix v4.21.0 adds a call-to-action prompt for span annotations in the UI.

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

• ›Adds a call-to-action prompt in the UI to guide users toward creating span annotations.

Phoenix v4.20.0 adds span annotations to dataset example metadata.

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

• ›Adds span annotations to dataset example metadata, making annotation data available alongside examples in datasets.

Phoenix v4.19.0 shows all annotations in the annotation summary on the project page header.

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

• ›Displays all annotations in the annotation summary within the project page header for at-a-glance visibility across a project.

Phoenix v4.18.0 adds annotation summaries, human span annotation editing, and slug support for session.view.

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

• ›Supports a slug parameter in session.view for direct project navigation.
• ›Adds annotation summaries to projects, surfacing aggregate label and score data at the project level.
• ›Enables editing of existing human span annotations in the UI.

Phoenix v4.17.0 adds a feedback column to spans/traces tables and a condensed trace tree view.

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

• ›Adds a feedback column to the spans and traces tables that surfaces all annotations at a glance.
• ›Introduces a condensed trace tree layout in the UI for a denser view of trace hierarchies.

Langfuse v2.75.0 adds tag filters across all tables, persistent filter state in session storage, and broad frontend performance improvements.

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

• ›Adds tag filter to the generations table and scores table, and adds trace tags as a column/filter in generations, sessions, and score tables.
• ›Persists table and dashboard filter state — including date range — in session storage so filters survive page navigation.
• ›Adds a jump-to-page input in table pagination for faster navigation across large result sets.
• ›Significant frontend performance improvements across traces, sessions, generations, and scores tables by parallelizing database queries and splitting total-count queries to reduce initial load time.
• ›Displays eval config sampling rate in the UI.

Langfuse v2.74.0 adds markdown rendering support for comments in the UI.

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

• ›Adds markdown rendering support for comments in the UI.

Langfuse v2.73.0 adds multi-modal trace viewing with support for OpenAI content part format (images and text).

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

• ›Adds multi-modal trace rendering in the UI, supporting the OpenAI content part format for displaying images and text within traces.

Langfuse v2.72.0 adds dataset duplication, object-level comments, and Stripe-powered cloud billing.

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

• ›Adds a duplicate dataset button in the UI to quickly clone existing datasets.
• ›Adds comments on objects (traces, observations, etc.) directly within the UI.
• ›Adds Stripe checkout, customer portal, and usage metering to Langfuse Cloud billing settings.
• ›Adds billing period and next invoiced amount display to Langfuse Cloud billing settings.

Langfuse v2.71.0 adds score analytics dashboards with aggregate and time series charts, plus audit logs for score configs.

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

• ›Adds aggregate and time series charts per score to the dashboard, enabling score analytics visualization.
• ›Adds audit logs for score config changes.

Langfuse v2.70.0 adds Organizations support, enterprise UI customization, and Redis-backed ingestion and export queues.

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

• ›Adds enterprise UI customization (configurable docs, support, and feedback links) via self-host enterprise edition settings.
• ›Adds Organizations support, enabling multi-organization management within a single Langfuse instance.
• ›Moves batch export queue from web to Redis, improving reliability and scalability of data exports.
• ›Ingestion pipeline now returns early and routes trace events through Redis, reducing latency for tracing workloads.

Langfuse v2.69.0 adds per-score columns in data tables, removes beta from trace timeline, and adds gpt-4o-2024-08-06 pricing and eval support.

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

• ›Adds gpt-4o-2024-08-06 model pricing and makes it available in the playground and evals.
• ›Breaks out scores into individual columns in data tables for easier comparison across traces and observations.
• ›Removes the beta flag from the trace timeline view, marking it generally available.

Langfuse v2.68.0 adds lastUpdatedAt, lastConfig, and date-range filters to the GET /v2/prompts API endpoint.

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

$ curl -X GET 'https://<your-langfuse-host>/api/public/v2/prompts?fromUpdatedAt=2024-06-01T00:00:00Z&toUpdatedAt=2024-06-30T23:59:59Z' \
  -H 'Authorization: Basic <base64-encoded-key>'

• ›Adds lastUpdatedAt field to GET /v2/prompts responses, exposing when each prompt was last modified.
• ›Adds lastConfig attribute and fromUpdatedAt / toUpdatedAt query parameters to GET /v2/prompts, enabling date-range filtering of prompt listings.
• ›Extends the maximum prompt label length from the previous limit to 36 characters in the UI.

Weave v0.50.15 adds Cerebras and Anthropic streaming integrations, PIL image support, call stream column selection, and evaluations page filtering.

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

import weave
import anthropic

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

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

import weave
from PIL import Image

weave.init('my-project')

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

process_image('screenshot.png')

• ›Adds invoke as a valid infer method for WeaveObject, expanding how model inference can be triggered.
• ›Adds simple column selection in call stream queries, letting callers retrieve only the fields they need.
• ›Adds first-class image support for PIL images, with a registered image serializer and type serializer in the manifest.
• ›Adds Anthropic Messages.stream support in the integration layer, enabling tracing of streaming Anthropic calls.
• ›Adds Cerebras as a supported integration.

Weave v0.50.14 adds object mutation support, data export (JSON/JSONL/CSV), configurable user settings, and feedback deletion in the UI.

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

• ›Adds export of trace/call data to JSON, JSONL, CSV, or selected rows to CSV directly from the UI.
• ›Adds limited mutation support for Table and WeaveTable objects, enabling in-place updates to tracked datasets.
• ›Adds limited mutation support for other Weave objects (excluding WeaveTable) via the object mutations API.
• ›Adds configurable user settings via the new user settings feature in the Python API.
• ›Adds feedback deletion capability in the UI, allowing users to remove previously submitted feedback entries.

Composio v0.5.7 adds AgentOps integration and a new website roaster tool.

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

• ›Adds AgentOps integration for agent observability and monitoring.
• ›Adds website_roaster tool for website analysis.
• ›Adds logging support to the core client.

Composio v0.5.0 adds human-in-the-loop support and removes legacy auth endpoints.

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

• ›Adds human-in-the-loop workflow capability, enabling agent actions to pause and await human approval or input before proceeding.
• ›Removes auth endpoints, consolidating authentication surface.

Composio v0.4.5 adds OpenAPI-spec-based JavaScript SDK generation.

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

• ›Generates a JavaScript SDK directly from the OpenAPI spec, enabling JS-native integration with Composio's action and trigger surfaces.

Composio v0.4.3 adds processors and metadata as plugin toolset arguments and a new frontend agent.

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

• ›Adds processors and metadata as plugin toolset arguments, enabling per-plugin configuration of request/response processing and contextual metadata.
• ›Adds a frontend agent capability to the platform.

Composio v0.4.2 adds Vercel AI SDK and Phidata integrations plus pre/post action processors

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

• ›Adds pre/post action processors and top-level metadata config support, enabling hooks to run before and after any action execution.
• ›New Vercel AI SDK integration, allowing Composio tools to be used directly within Vercel AI workflows.
• ›New Phidata plugin, adding Composio support for the Phidata agent framework.
• ›Updates e2b sandbox support in the JS SDK (bumped to v0.1.12).

Composio v0.4.1 adds browser tool support, LangGraph scaffolding, system tools, and a LlamaIndex agent integration.

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

• ›Adds a browser tool integration for agent-driven web interaction.
• ›Adds LangGraph scaffolding to support LangGraph-based agent workflows.
• ›Adds system tools and a Rewind integration example.
• ›Adds a LlamaIndex agent integration.
• ›Enables API key retrieval from login credentials, streamlining authentication setup.

LanceDB v0.10.0-beta.1 adds scalar index types on remote tables, FTS query/index on RemoteTable/AsyncTable, and a delete unverified parameter for Python and Node.js.

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

• ›Adds delete unverified parameter to the Python client, enabling unverified deletes via the Python API.
• ›Adds delete unverified support to the Node.js client for unverified delete operations.
• ›Supports querying and indexing Full-Text Search (FTS) on RemoteTable and AsyncTable.
• ›Allows new scalar index types to be created on remote tables.

LanceDB python-v0.13.0-beta.0 migrates FTS to lance-index and adds bitmap/label-list scalar index support to the async API.

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

results = await table.query().where("category = 'news'").to_list()

await table.create_scalar_index("category", index_type="BITMAP")

• ›Adds to_list() to the async Python API, enabling async result collection from query results.
• ›Adds bitmap and label list scalar index creation via the Python async API.
• ›Migrates full-text search (FTS) backend from tantivy to lance-index, replacing the previous FTS engine.
• ›Adds bitmap and label list index types to the Node.js API.

LanceDB v0.10.0-beta.0 migrates FTS to lance-index and adds bitmap/label-list scalar indexes in Python and Node.js

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

• ›Adds to_list() to the Python async API for collecting query results asynchronously.
• ›Adds bitmap and label-list scalar index creation via the Python async API.
• ›Adds bitmap and label-list index types to the Node.js API.
• ›Migrates full-text search (FTS) from tantivy to lance-index, replacing the underlying FTS engine.

LanceDB Python v0.12.0 adds WatsonX embeddings, multi-vector reranking, and remote table embedding support.

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

• ›Adds WatsonX embeddings to the embedding function registry for use with LanceDB tables.
• ›Adds multi-vector reranking support, enabling reranking across multiple vector search results in a single query.
• ›Supports embedding functions on remote tables, bringing parity with local table embedding workflows.
• ›Upgrades lance to v0.16, improving the underlying storage and query engine.

Milvus 2.4.8 adds clustering compaction, OTLP HTTP export, async CGO search, and expanded system metrics.

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

• ›Adds range_search_k parameter support in Knowhere to speed up range searches.
• ›Adds OTLP HTTP exporter support for observability and monitoring.
• ›Introduces configurable database properties max collections and disk quota, dynamically modifiable at runtime.
• ›Enables configuration of replica numbers and resource groups at the cluster, database, and collection levels with support for dynamic modifications.
• ›Implements clustering compaction — data redistributed based on a designated clustering key to reduce scanned data and enhance query efficiency.

Milvus v2.3.21 adds disk quota, max insert rate, and query node memory metrics alongside a changed autoindex default metric type.

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

• ›Adds metrics to track disk quota usage.
• ›Adds metrics to record maxinsertrate and querynodememoryhighwaterlevel.
• ›Adds tracking for the number of times Milvus enters a force-deny-writing state.
• ›Changes the default metric type for autoindex.

Qdrant v1.11.0 adds GroupBy in Query API, UUID payload index, Distribution-based Score Fusion, random sampling, and a graph-based collection explorer.

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

• ›Adds group_by support to the Query API, enabling grouped vector search results in a single request.
• ›Introduces a UUID payload index type for indexing and filtering on UUID fields.
• ›Adds on-disk index support for Keyword, Integer, Datetime, Float, and UUID indexes, reducing RAM requirements for large collections.
• ›Adds random sampling support in the Query API for approximate or exploratory queries.
• ›Adds Distribution-based Score Fusion (DBSFusion) as a new score fusion strategy for hybrid search.

Weaviate v1.25.13 adds Mistral text2vec module and concurrent vectorization — but is flagged broken; upgrade to v1.25.20.

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

• ›Adds Mistral text2vec module, enabling Mistral-backed text vectorization for collections.
• ›Adds concurrent vectorization support, allowing multiple vectors to be computed in parallel during ingestion.

Weaviate v1.24.23 adds an experimental repair endpoint for cluster data repair operations.

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

• ›Adds an experimental repair endpoint for repairing data in a Weaviate cluster.