The AI Toolchain — issue -370, January 31, 2025

Agno v1.0.1 enables response caching for Mistral models.

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

• ›Enables caching support for Mistral models.

Agno v1.0.0 introduces an Evals framework and a fully restructured multi-modal API with typed Image, Audio, Video, and Artifact classes.

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

from agno.knowledge.pdf_url import PDFUrlKnowledgeBase
from agno.vectordb.pgvector import PgVector
from agno.embedder.ollama import OllamaEmbedder

knowledge_base = PDFUrlKnowledgeBase(
    urls=['https://phi-public.s3.amazonaws.com/recipes/ThaiRecipes.pdf'],
    vector_db=PgVector(
        table_name='recipes',
        db_url='postgresql+psycopg://ai:ai@localhost:5532/ai',
        embedder=OllamaEmbedder(id='llama3.2', dimensions=3072),
    ),
)
knowledge_base.load(recreate=True)

• ›Adds an Evals system to measure performance, accuracy, and reliability of agents.
• ›Typed multi-modal input classes — Image, Audio, Video — now accepted by agent.run() and agent.print_response(), with fields for url, filepath, content, detail, format, and id.
• ›Typed output artifact classes — ImageArtifact, AudioArtifact, VideoArtifact, AudioOutput — now returned on RunResponse.images, RunResponse.audio, RunResponse.videos, and RunResponse.response_audio.
• ›Embedders now accept id instead of model as the identifier parameter (e.g. OllamaEmbedder(id='llama3.2', dimensions=3072)).
• ›All toolkit classes are now suffixed with Tools (e.g. DuckDuckGoTools).

AutoGPT Platform v0.4.2 adds Twitter integration, API key generation, Nvidia deepfake detection, and new GitHub blocks.

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

• ›Adds API key generation frontend, enabling users to create and manage API keys directly from the UI.
• ›Adds TERMINATED execution status to the backend executor, providing a new distinct state for agent run lifecycle tracking.
• ›Adds Twitter integration block, enabling agents to interact with Twitter as a connected service.
• ›Adds Nvidia Deepfake Detection block via backend/blocks/nvidia, with Nvidia provided as a default backend.
• ›Adds GitHub Create File block for automating file creation in repositories.

CrewAI 0.98.0 adds Conversation Crew, flow state persistence with @persist, and SambaNova/NVIDIA NIM/VoyageAI integrations.

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

from crewai.flow.persistence import persist, FlowPersistence

class MySecurityFlow(Flow):
    @persist
    def analyze_targets(self):
        # state is automatically saved after this method completes
        ...

• ›New Conversation Crew v1 enables interactive, dialogue-driven crew execution.
• ›Adds unique IDs to flow states for tracking and referencing individual flow runs.
• ›New @persist decorator with FlowPersistence interface enables durable flow state persistence across runs.
• ›Adds SambaNova as a new LLM provider integration.
• ›Adds NVIDIA NIM as a new provider via the CrewAI CLI.

CrewAI 0.95.0 adds multimodal agents, programmatic guardrails, multi-round HITL, Gemini 2.0, Langfuse, Portkey, Docling, and Weaviate support.

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

• ›Adds multimodal abilities to Crew, enabling agents to process image and other non-text inputs.
• ›Introduces programmatic guardrails for enforcing constraints on agent outputs at runtime.
• ›Supports multiple rounds of Human-in-the-Loop (HITL) interaction within a single crew run.
• ›Adds Gemini 2.0 model support.
• ›Delivers CrewAI Flows improvements for more capable workflow orchestration.

DSPy 2.6.0rc8 adds AlfWorld dataset, sandboxed Python interpreter, and dspy.__version__ introspection.

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

import dspy
print(dspy.__version__)

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

langchain-mistralai 0.2.5 adds JSON Schema structured output and AI message prefix support for MistralAI.

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

from langchain_mistralai import ChatMistralAI
from pydantic import BaseModel

class Answer(BaseModel):
    answer: str
    confidence: float

llm = ChatMistralAI(model='mistral-large-latest')
structured = llm.with_structured_output(Answer, method='json_schema')
result = structured.invoke('What is the capital of France?')
print(result)

• ›Supports method='json_schema' in structured output calls, enabling strict JSON Schema-based response shaping with MistralAI models.
• ›Allows setting a Prefix in AIMessage for MistralAI, enabling prefill/prefix-guided generation workflows.

langchain-community 0.3.16 adds GitHub releases retrieval, SambaNova integration, and broader Azure AI credential support.

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

• ›Adds support for fetching GitHub releases for a configured repository via the GitHub tool.
• ›Adds the sambanova-langchain integration package for SambaNova LLM support.
• ›Allows setting a custom GitLab URL in the GitLab tool constructor.

LangChain 0.3.16 adds DeepSeek and Ollama provider support to init_chat_model and init_embeddings.

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

from langchain.chat_models import init_chat_model

llm = init_chat_model("deepseek-chat", model_provider="deepseek")

from langchain.embeddings import init_embeddings

embeddings = init_embeddings("ollama", model="nomic-embed-text")

• ›Adds deepseek as a supported provider in init_chat_model, enabling direct DeepSeek model initialization alongside existing providers.
• ›Adds ollama support in init_embeddings, allowing Ollama embedding models to be initialized through the unified embeddings factory.

langchain-community 0.3.15 adds image blob parsers, PyMuPDF refactor, OBSFileLoader mode arg, and page_label metadata for PyPDF.

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

from langchain_community.document_loaders import OBSFileLoader

loader = OBSFileLoader(bucket='my-bucket', key='docs/file.txt', mode='text')
docs = loader.load()

• ›Adds mode argument to OBSFileLoader.load() to control file loading behavior.
• ›Adds page_label field to metadata in PyPDFLoader output, exposing PDF page labels alongside page numbers.
• ›Refactors PyMuPDFParser and PyMuPDFLoader and introduces new image blob parsers for extracting images from PDFs.
• ›Streams citations from ChatPerplexity into additional_kwargs on response chunks.
• ›Adds stream() method support to the Xinference LLM integration alongside a rewritten _stream() method.

LangChain 0.3.15 adds API key argument support to OpenAI moderation chain and expands OpenAI Assistant parameters.

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

• ›Adds api_key argument support to the OpenAI moderation chain, enabling per-call key configuration.
• ›Adds additional_instructions parameter to OpenAI Assistant runs create calls via OpenAIAssistantV2Runnable.
• ›Adds additional parameters to OpenAIAssistantV2Runnable for broader control over assistant run configuration.

langchain-anthropic 0.3.2 adds parallel_tool_calls support for Anthropic chat models.

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

• ›Adds parallel_tool_calls parameter to Anthropic chat model calls, enabling concurrent tool invocation in a single model turn.

langchain-core 0.3.30 allows retriever tools to surface artifacts alongside retrieved documents.

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

• ›Allows artifact to be passed in create_retriever_tool, enabling retriever tools to return artifact data alongside retrieved documents.

langchain-openai 0.3 switches structured output to json_schema by default and removes hardcoded parameter defaults.

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

from langchain_openai import ChatOpenAI
from typing import TypedDict

class Answer(TypedDict):
    score: int
    reasoning: str

llm = ChatOpenAI(model='gpt-4o-mini')
structured = llm.with_structured_output(Answer, method='json_schema', strict=True)
result = structured.invoke('Rate the following code quality from 1-10 and explain why.')

from langchain_openai import ChatOpenAI
from pydantic import BaseModel, Field

class Verdict(BaseModel):
    confidence: float = Field(ge=0.0, le=1.0)
    label: str

llm = ChatOpenAI(model='gpt-3.5-turbo', temperature=0.7, max_retries=2, n=1)
structured = llm.with_structured_output(Verdict, method='function_calling')
result = structured.invoke('Classify the following text as spam or ham.')

• ›Changes the default method parameter of ChatOpenAI(...).with_structured_output() from 'function_calling' to 'json_schema', using OpenAI's dedicated structured output feature instead of function calling.
• ›Adds support for strict=True in with_structured_output() to enable strict schema validation for schemas specified via TypedDict or JSON schema (disabled by default).

langchain-chroma 0.2.0 adds get_by_ids, embedding vector retrieval, and document.id support to the Chroma vector store.

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

• ›Adds get_by_ids method to the Chroma vector store for direct document lookup by ID.
• ›Adds document.id support so documents carry their IDs through the Chroma store.
• ›Enables retrieval of embedding vectors alongside documents from a Chroma collection.
• ›Passes through kwargs to Chroma collection.delete, exposing the full Chroma delete API surface.

langchain-text-splitters 0.3.5 adds HTMLSemanticPreservingSplitter for structure-aware HTML chunking.

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

from langchain_text_splitters import HTMLSemanticPreservingSplitter

splitter = HTMLSemanticPreservingSplitter()
chunks = splitter.split_text(html_content)

• ›Adds HTMLSemanticPreservingSplitter class for splitting HTML documents while preserving semantic structure.

langchain-community 0.3.14 adds SQL LanguageParser and expands AzureSearch credential support

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

• ›Adds SQL LanguageParser to langchain_community, enabling parsing of SQL files as a supported language in document loaders.
• ›Adds embed_documents and embed_query methods to LlamaCppEmbeddings, enabling batch and single-query embedding with the local Llama.cpp backend.
• ›Changes DuckDuckGoSearchAPIWrapper default backend from api to auto, broadening search fallback behavior.

LangChain 0.3.14 adds Google Anthropic Vertex AI model garden support to init_chat_model.

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

• ›Adds support for the Google Anthropic Vertex AI model garden provider in init_chat_model, enabling Anthropic models hosted on Vertex AI to be initialized through the standard chat model factory.

LangGraph CLI now supports auth configuration in langgraph.json with path validation and Docker container handling.

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

{
  "graphs": {
    "my_agent": "./agent.py:graph"
  },
  "auth": {
    "path": "./auth/handler.py:auth"
  }
}

• ›Supports auth configuration block in langgraph.json, with validation that auth.path follows the required ./path/to/file.py:attribute_name format.
• ›Enables auth path resolution in Docker environments via new _update_auth_path function, so auth handlers are correctly wired when deploying containers.

LangGraph 0.2.68 promotes the Functional API to Beta and adds a name parameter to the task decorator.

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

from langgraph.func import task

@task(name="fetch_user_profile")
def _t(user_id: str) -> dict:
    # your implementation
    return {"id": user_id}

future = _t("u-123")
result = future.result()

from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

agent = create_react_agent(
    model=ChatOpenAI(model="gpt-4o"),
    tools=[...],
    prompt="You are a concise security analyst. Answer in bullet points.",
)

result = agent.invoke({"messages": [{"role": "user", "content": "Summarize CVE-2024-1234"}]})

• ›Adds name parameter to the task decorator, allowing custom display names for tasks regardless of the underlying function name.
• ›Promotes the Functional API (@task, @entrypoint) from Experimental to Beta status with expanded documentation.
• ›Introduces unified SyncAsyncFuture type in langgraph.pregel.call that implements both the Future interface and the awaitable protocol for task return values.
• ›Renames state_modifier parameter to prompt in create_react_agent, with full backward compatibility retained.

LangGraph CLI now ships PostgreSQL with pgvector enabled for vector operations support.

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

• ›Upgrades the bundled PostgreSQL Docker image to pgvector/pgvector:pg16, enabling vector operations in local dev environments.
• ›Loads the pgvector extension automatically via shared_preload_libraries=vector in the generated Docker Compose configuration.

LangGraph 0.2.67 adds entrypoint.final for separating return vs. checkpointed values and async state modifiers in the chat agent executor.

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

from langgraph.func import entrypoint

@entrypoint(checkpointer=checkpointer)
def my_graph(input: str) -> entrypoint.final[str, dict]:
    result = run_pipeline(input)
    # Return the string to the caller; save the full dict to the checkpoint
    return entrypoint.final(value=result["summary"], save=result)

• ›Adds entrypoint.final primitive to return a value to the caller that differs from the value saved in the checkpoint.
• ›Supports async coroutine functions as state modifiers in the chat agent executor.
• ›Adds thread-safe atomic counters in PregelScratchpad for safer concurrent graph execution.
• ›Supports Union types in node function return annotations so add_node correctly extracts Command types.
• ›Enhances Command.update with automatic field extraction from type hints on dataclasses and typed objects.

LangGraph 0.2.66 adds run_coroutine_threadsafe, explode_args, and trace_inputs for safer async execution and richer tracing.

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

from langgraph.utils.future import run_coroutine_threadsafe
import asyncio

loop = asyncio.get_event_loop()
future = run_coroutine_threadsafe(my_async_task(), loop)
result = future.result(timeout=30)

from langgraph.utils.runnable import RunnableSeq

seq = RunnableSeq(
    step_a,
    step_b,
    trace_inputs=lambda x: {"sanitized_input": x["query"]},
)
result = seq.invoke({"query": "explain RBAC", "user_token": "s3cr3t"})

• ›Adds explode_args parameter to RunnableCallable to unpack a tuple of (args, kwargs) instead of passing it as the first positional argument; affects both invoke and ainvoke methods.
• ›Adds trace_inputs parameter to RunnableSeq to customize how inputs are recorded in callbacks across invoke, ainvoke, stream, and astream.
• ›Adds run_coroutine_threadsafe function in langgraph.utils.future for safely running coroutines from any thread context.
• ›Adds CONTEXT_NOT_SUPPORTED flag in langgraph.utils.future to handle Python versions whose event loops do not support contextvars.
• ›Adds get_runnable_for_entrypoint and get_runnable_for_task functions in langgraph.pregel.call for targeted handling of distinct execution contexts.

LangGraph 0.2.65 adds graph visualization for entrypoint functions and a new get_store() utility for easy store access.

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

from langgraph.func import entrypoint, task

@task
def fetch_data(url: str):
    ...

@entrypoint()
def pipeline(input: dict):
    return fetch_data(input["url"]).result()

# pipeline is now an EntrypointPregel
graph = pipeline.get_graph(xray=True)
graph.print_ascii()

from langgraph.config import get_store

@task
def save_result(key: str, value: str):
    store = get_store()
    store.put(("results",), key, {"value": value})

• ›New EntrypointPregel class exposes a get_graph() method to visualize entrypoint functions and their dependent tasks, including nested subgraphs via x-ray mode.
• ›New get_store() utility function retrieves the BaseStore from the current config context without manual extraction.
• ›Tasks decorated with @task now carry a _is_pregel_task attribute, making them automatically discoverable for graph visualization.

LangGraph CLI 0.1.68 adds Bun package manager support and clearer JS-graph error guidance.

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

• ›Supports Bun as a detected package manager: detects bun.lockb and runs bun i automatically for Bun-based projects.
• ›Adds a clear error message when users attempt to run JS graphs with the Python CLI, directing them to use npx @langchain/langgraph-cli instead.

LangGraph 0.2.64 adds config schema validation and previous state access to the entrypoint decorator.

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

from langgraph.func import entrypoint
from pydantic import BaseModel

class MyConfig(BaseModel):
    temperature: float = 0.7
    max_tokens: int = 256

@entrypoint(config_schema=MyConfig)
def my_workflow(inputs: dict) -> str:
    # config is validated against MyConfig before execution
    ...

from langgraph.func import entrypoint

@entrypoint()
def my_workflow(inputs: dict, previous: list | None = None) -> list:
    history = previous or []
    history.append(inputs["message"])
    return history

• ›Adds config_schema parameter to the entrypoint decorator, enabling schema validation for workflow configuration.
• ›Adds support for an optional previous parameter in entrypoint-decorated functions to access the prior return value in stateful Pregel graphs.
• ›Adds automatic input/output type detection from function signatures in the entrypoint decorator, removing the need for manual type annotation wiring.

LangGraph 0.2.63 adds subgraph checkpointing, string model IDs in create_react_agent, human-interrupt types, and eager streaming.

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

subgraph = subgraph_builder.compile(checkpointer=True)
parent = parent_builder.compile(checkpointer=memory_checkpointer)
parent.add_node("sub", subgraph)

from langgraph.prebuilt import create_react_agent

agent = create_react_agent("openai:gpt-4", tools)

• ›Supports checkpointer=True on subgraphs to enable persistent checkpointing without passing a full checkpointer object.
• ›Accepts string model identifiers in create_react_agent, e.g. create_react_agent("openai:gpt-4", tools).
• ›Adds structured type definitions for human-in-the-loop interactions: HumanInterruptConfig, ActionRequest, HumanInterrupt, and HumanResponse in langgraph.prebuilt.interrupt.
• ›Adds stream_eager option to langgraph.pregel to force stream events to emit eagerly.
• ›Enables method chaining on add_node, add_edge, add_sequence, add_conditional_edges, set_entry_point, set_conditional_entry_point, and set_finish_point via updated Self return types.

langgraph-checkpoint-postgres 2.0.12 adds task_path tracking to checkpoint writes for better data organization.

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

await saver.aput_writes(config, writes, task_id, task_path="agent/subgraph")

• ›Adds task_path parameter to put_writes() and aput_writes() on all saver classes (PostgresSaver, AsyncPostgresSaver, ShallowPostgresSaver, AsyncShallowPostgresSaver) to tag checkpoint writes with their originating task path.
• ›Extends the checkpoint_writes table schema with a task_path column, enabling path-based ordering and querying of checkpoint write records.

LangGraph SQLite checkpointer adds task_path parameter to write-tracking methods for improved task traceability.

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

saver.put_writes(config, writes, task_id, task_path="agent:tool_call")

await async_saver.aput_writes(config, writes, task_id, task_path="agent:tool_call")

• ›Adds optional task_path parameter to SqliteSaver.put_writes() for tracking which task path created a given set of writes.
• ›Adds optional task_path parameter to AsyncSqliteSaver.put_writes() and AsyncSqliteSaver.aput_writes() for async task traceability.

LangGraph checkpoint 2.0.10 adds task path tracking to put_writes/aput_writes for consistent ordering in nested task graphs.

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

saver.put_writes(config, writes, task_id, task_path="parent_task/child_task")

• ›Adds task_path parameter to put_writes and aput_writes on BaseCheckpointSaver and InMemorySaver to track the nested path of tasks creating checkpoint writes.
• ›Enables deterministic, consistent ordering of pending sends by sorting on task path, task ID, and sequence number during checkpoint retrieval.

LangGraph DuckDB checkpointer adds in-memory vector search support

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

• ›Adds in-memory vector search capability to the DuckDB checkpointer

LangGraph 0.2.62 adds a response_format parameter to create_react_agent for structured, schema-validated agent outputs.

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

from pydantic import BaseModel
from langgraph.prebuilt import create_react_agent

class AgentAnswer(BaseModel):
    answer: str
    confidence: float

agent = create_react_agent(
    model,
    tools=[...],
    response_format=AgentAnswer,
)
result = agent.invoke({"messages": [("user", "What is the capital of France?")]})
print(result["structured_response"])  # AgentAnswer(answer='Paris', confidence=0.99)

from typing import TypedDict
from langgraph.prebuilt import create_react_agent

class Summary(TypedDict):
    key_findings: list[str]
    risk_level: str

agent = create_react_agent(
    model,
    tools=[...],
    response_format=(
        "Extract the security findings and risk level from the conversation.",
        Summary,
    ),
)
result = agent.invoke({"messages": [("user", "Analyze this log: ...")]})
print(result["structured_response"])

• ›Adds response_format parameter to create_react_agent to enforce a schema on final agent output, returned in the structured_response state key.
• ›Supports OpenAI function/tool schemas, JSON Schema, TypedDict classes, and Pydantic models as the response schema.
• ›Accepts a (prompt, schema) tuple for response_format to supply a custom prompt when generating structured output.

LangGraph SDK 0.1.50 adds store authorization handlers and expands Command.update to accept tuple sequences.

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

from langgraph.types import Command

updates = [("messages", new_message), ("turn_count", 5)]
cmd = Command(update=updates)

• ›Adds auth.on.store decorators to authorize store operations (put, get, search, list_namespaces, delete) at the handler level.
• ›Introduces new TypedDict classes — StoreGet, StoreSearch, StoreListNamespaces, StorePut, StoreDelete — for typed store operation authorization.
• ›Expands Command.update to accept sequences of tuples in addition to dictionaries, enabling more flexible graph state updates.

LangGraph 0.2.61 adds OpenAI-format message conversion to add_messages and a more flexible task decorator with async support.

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

from langgraph.graph.message import add_messages
from typing import Annotated
from typing_extensions import TypedDict

class State(TypedDict):
    messages: Annotated[list, add_messages(format="langchain-openai")]

from langgraph.func import task

@task
async def fetch_data(url: str, timeout: int = 30) -> dict:
    # async I/O here
    ...

• ›Adds format="langchain-openai" parameter to add_messages to automatically convert message content (strings, text blocks, image_url blocks) to OpenAI-compatible format.
• ›Enables add_messages as a partial function when called without arguments, improving flexibility in type annotations.
• ›Rewrites the task decorator to support both direct (@task) and parameterized (@task(...)) usage, with proper coroutine detection and wrapping for async functions.
• ›Expands task decorator function signature to accept *args and **kwargs and adds overloads for better IDE type inference.

Letta 0.6.8 adds provider persistence so configured providers survive restarts.

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

• ›Adds provider persistence so that configured LLM/embedding providers are saved and restored across server restarts.

AutoGen v0.4.3 adds model response caching, GraphRAG tools, Semantic Kernel adapters, Jupyter execution, and agent memory.

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

from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.models.cache import ChatCompletionCache, CHAT_CACHE_VALUE_TYPE
from autogen_ext.cache_store.diskcache import DiskCacheStore
from autogen_core.models import UserMessage
from diskcache import Cache
import asyncio

async def main():
    openai_client = OpenAIChatCompletionClient(model="gpt-4o")
    cache_store = DiskCacheStore[CHAT_CACHE_VALUE_TYPE](Cache("/tmp/autogen-cache"))
    cache_client = ChatCompletionCache(openai_client, cache_store)

    response = await cache_client.create([UserMessage(content="Summarise zero-trust networking.", source="user")])
    print(response)  # live response
    response = await cache_client.create([UserMessage(content="Summarise zero-trust networking.", source="user")])
    print(response)  # served from disk cache

asyncio.run(main())

from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_ext.tools.graphrag import GlobalSearchTool
from autogen_agentchat.agents import AssistantAgent
from autogen_agentchat.ui import Console
import asyncio

async def main():
    global_tool = GlobalSearchTool.from_settings(settings_path="./settings.yaml")
    agent = AssistantAgent(
        name="search_assistant",
        tools=[global_tool],
        model_client=OpenAIChatCompletionClient(model="gpt-4o-mini"),
        system_message="Use global_search for broad questions about the dataset.",
    )
    await Console(agent.run_stream(task="What are the main themes across all community reports?"))

asyncio.run(main())

• ›Adds ChatCompletionCache to wrap any ChatCompletionClient and transparently cache model completions, with DiskCacheStore and RedisStore backends via a new CacheStore interface.
• ›Adds LocalSearchTool and GlobalSearchTool for GraphRAG integration, enabling agents to call local and global graph-based retrieval as first-class tools.
• ›Adds SKChatCompletionAdapter to adapt any Semantic Kernel AI Connector into an AutoGen ChatCompletionClient.
• ›Adds KernelFunctionFromTool adapter to expose AutoGen tools as Kernel functions inside a Semantic Kernel workflow.
• ›Adds JupyterCodeExecutor for local Jupyter-based code execution, restoring functionality from the 0.2 lineage.

AutoGen v0.4.1 enables subclassing BaseComponent for custom serializable component configs.

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

• ›Supports subclassing BaseComponent to create custom component configs with serialization support.

AutoGen v0.4.0 stable: agent activate/deactivate, o1-2024-12-17 model support, and new m1 CLI package.

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

• ›Adds m1 CLI package for interacting with AutoGen agents from the command line.
• ›Supports activating and deactivating individual agents at runtime.
• ›Adds support for the o1-2024-12-17 model in autogen-ext[openai].

PydanticAI v0.0.20 adds Cohere model support, Anthropic streaming, parallel tool calls, and DeepSeek-R1 via Ollama.

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

from pydantic_ai import Agent
from pydantic_ai.settings import ModelSettings

agent = Agent('openai:gpt-4o', model_settings=ModelSettings(parallel_tool_calls=False))
result = agent.run_sync('Book a flight and then a hotel')

• ›Adds parallel_tool_calls field to ModelSettings to control whether the model may invoke multiple tools simultaneously.
• ›Adds model_name field to ModelResponse, exposing which model produced each response.
• ›Adds support for Cohere models as a new model provider integration.
• ›Adds 'deepseek-r1' to the recognized Ollama model name list, enabling typed use of DeepSeek-R1 via Ollama.
• ›Adds Anthropic streaming support, enabling streamed responses from Anthropic models.

PydanticAI v0.0.19 adds graph support, tool docstring controls, streaming refactor, and phi4 on Ollama.

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

• ›Adds docstring_format and require_parameter_descriptions parameters to tool definitions, giving callers explicit control over how tool schemas are generated from Python docstrings.
• ›Introduces graph support via pydantic_ai.graph, enabling stateful, multi-step agent workflows modelled as explicit graphs.
• ›Adds phi4 model support to the Ollama provider.
• ›Refactors streaming internals, improving the reliability and composability of streamed agent responses.

PydanticAI v0.0.18 adds dynamic system prompts, per-run custom result types, and provider-prefixed model names.

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

@agent.system_prompt(dynamic=True)
def my_prompt(ctx: RunContext) -> str:
    return f"Today is {date.today()}. User: {ctx.deps.username}"

result = await agent.run("Summarise this", result_type=MySummaryModel)

• ›Adds dynamic parameter to the system_prompt decorator, enabling system prompts to be re-evaluated on each agent run rather than computed once at definition time.
• ›Supports custom result_type overrides on individual .run() calls, allowing the expected output type to be set per-run without changing the agent definition.
• ›All model names are now prefixed with their provider (e.g. openai:gpt-4o) for consistency across providers.

PydanticAI v0.0.17 defaults AgentDeps to None and adds formatting examples support

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

• ›Adds formatting examples support to improve how examples are structured and displayed.
• ›AgentDeps now defaults to None, simplifying agent definitions that do not require explicit dependency typing.

Semantic Kernel dotnet-1.35.0 adds Azure AI Agent support, Ollama/Aspire integration, cloud-event scaffolding, and Gemini cached-content settings.

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

var settings = new GeminiPromptExecutionSettings
{
    CachedContent = "cachedContents/my-cached-system-prompt"
};
var result = await kernel.InvokePromptAsync(prompt, new KernelArguments(settings));

• ›Adds CachedContent property to GeminiPromptExecutionSettings for controlling Gemini prompt caching behavior.
• ›Adds Azure AI Agent support via the Agents package (#10134), enabling Azure AI Foundry-hosted agents alongside existing agent types.
• ›Adds Ollama extension for improved .NET Aspire integration experience.
• ›Introduces SK Process Cloud Events publish interface abstractions and scaffolding, enabling cloud-event-driven process orchestration.
• ›Moves IChatHistoryReducer from the Agents package into core SK packages, broadening its availability across the library.

Semantic Kernel dotnet-1.34.0 adds Base64 image support for MistralAI, structured output schema for Google Gemini, and async streaming for Bedrock Converse.

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

• ›Adds support for Base64 encoded images in MistralAI connector, enabling inline image payloads without external URLs.
• ›Adds structured outputs (response schema) support for Google Gemini, allowing callers to constrain model responses to a defined schema.
• ›Adds async support for ConverseStreamResponse in the AWS Bedrock connector to avoid thread blocking during streaming.
• ›Adds a request index to streamed function call update content, enabling callers to correlate parallel streamed tool calls.

Semantic Kernel Python 1.19.0 adds DEVELOPER role support for OpenAI o1 models and agent invocation tracing spans.

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

• ›Adds agent invocation spans for observability tracing of agent calls.
• ›Supports the DEVELOPER role for OpenAI o1 models, enabling o1-compatible message construction.

Semantic Kernel Python 1.18.0 removes the deprecated OpenAI plugin and improves Azure assistant agent settings and retrieval.

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

• ›Improves Azure assistant agent settings and retrieval operations.
• ›Removes the deprecated OpenAI plugin, aligning the Python library with the .NET version.

Semantic Kernel 1.33.0 adds strict mode for OpenAI, a Postgres vector store, OpenAPI response factory, and name-based agent strategies.

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

var settings = new OpenAIPromptExecutionSettings
{
    Store = true,
    Metadata = new Dictionary<string, string> { { "session", "abc123" } }
};

• ›Adds store and metadata properties to OpenAIPromptExecutionSettings for controlling prompt execution context.
• ›Adds strict mode support for OpenAI function calling via OpenAIPromptExecutionSettings.
• ›Adds a factory for customizing OpenAPI plugin responses, enabling per-operation response transformation.
• ›Adds PostgresVectorStore memory connector for vector similarity search backed by PostgreSQL.
• ›Adds support for name-based KernelFunctionSelectionStrategy and KernelFunctionTerminationStrategy in .NET Agents, allowing strategies to be resolved by function name.

browser-use 0.1.26 adds viewport_expansion and highlight_elements controls for page context and visual output.

$ git clone --branch 0.1.26 https://github.com/browser-use/browser-use.git
# already have the repo? check out this version:
$ git checkout 0.1.26

agent = Agent(
    task="...",
    browser=browser,
    highlight_elements=False
)

• ›Adds viewport_expansion setting to control how much of the page is included in context, defaulting to slightly beyond the visible viewport; set it to the full page size to include all content.
• ›Adds highlight_elements setting (set to False) to suppress element highlight overlays in the browser view.

camel-ai v0.2.18 adds DeepSeek R1 reasoning content support, a new DeepSeek Reasoner model, and native tool calls for SambaCloud and TogetherAI.

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

• ›Supports extracting reasoning content from DeepSeek R1 model responses via the model backend.
• ›Adds deepseek_reasoner model to the supported model list.
• ›Enables native tool call support for SambaCloud and TogetherAI providers.

camel-ai v0.2.17 adds Discord OAuth, InternLM models, Skywork reward model, Source2Synth, and a structured document loader.

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

• ›Adds Discord OAuth Flow integration, enabling agent workflows to authenticate with Discord.
• ›Integrates InternLM models as a supported model backend.
• ›Adds Skywork reward model support for scoring and evaluating agent outputs.
• ›Adds Source2Synth for synthetic data generation from source material.
• ›Adds a structured document loader via feat: structured loader for ingesting structured data into agent pipelines.

camel-ai v0.2.16 adds the Dappier toolkit for real-time AI-powered data access.

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

• ›Adds DappierToolkit integration, enabling agents to query Dappier's real-time data and AI recommendations API.

camel-ai v0.2.15 adds graph sampling via Neo4j, OpenBB and Linkup integrations, new benchmarks, native structured output, and a self-instruct pipeline.

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

• ›Adds native structured output property to ChatAgent, enabling schema-enforced responses without post-processing.
• ›Adds graph sampling support with Neo4j integration for graph-based retrieval workflows.
• ›Adds time-label support to the NebulaGraph integration.
• ›Integrates Linkup as a new data-source provider.
• ›Integrates OpenBB into the library for financial data access within agentic workflows.

smolagents v1.6.0 adds VLM auto-detection, DuckDuckGo kwargs, richer Gradio chatbot metrics, and makes transformers an optional dependency.

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

from smolagents import DuckDuckGoSearchTool

tool = DuckDuckGoSearchTool(ddgs_kwargs={"proxies": "http://proxy.corp:8080", "region": "us-en"})
results = tool("latest CVE disclosures")

• ›Adds ddgs_kwargs parameter to the DuckDuckGoSearchTool constructor, allowing callers to pass arbitrary keyword arguments to the underlying DDGS client.
• ›Adds additional parameters support for the OpenAI client integration.
• ›Adds kwargs passthrough to gradio launch, enabling full control over Gradio server startup options.
• ›TransformersModel now auto-detects Vision-Language Models (VLMs), removing the need for manual configuration when loading a VLM.
• ›Makes transformers an optional dependency, reducing the mandatory install footprint for users who do not need local transformer inference.

smolagents v1.5.0 adds VLM support, Azure OpenAI integration, and tightened local interpreter security

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

• ›Adds Azure OpenAI support as a model backend.
• ›Adds VLM (vision-language model) support, enabling agents to process image inputs.
• ›Hardens local interpreter security: builtin functions are now blocked unless explicitly added as tools.
• ›Supports any and none tool types in tool call handling.

smolagents v1.4.1 adds MCP server support via ToolCollection, kwargs passthrough to all models, and new TransformersModel options.

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

from smolagents import TransformersModel

model = TransformersModel(
    model_id="org/custom-model",
    trust_remote_code=True
)

• ›Adds trust_remote_code argument to TransformersModel for loading custom model code from remote repositories.
• ›Adds MCP (Model Context Protocol) server support via ToolCollection, making thousands of MCP-compatible tools usable with smolagents.
• ›Allows passing arbitrary kwargs to all model classes, enabling fine-grained control over inference parameters at call time.
• ›Makes the openai package an optional dependency, reducing mandatory install footprint.
• ›Adds a max-length parameter for print outputs as an agent-level setting to cap verbose tool output.

smolagents v1.3.0 adds OpenTelemetry tracing, multi-GPU support, wildcard imports, and granular verbosity control.

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

from smolagents import CodeAgent, HfApiModel

agent = CodeAgent(
    tools=[],
    model=HfApiModel(),
    verbosity_level=2  # 0=silent, 1=normal, 2=verbose
)
agent.run('Summarize the latest CVE advisories.')

from smolagents import CodeAgent, HfApiModel

agent = CodeAgent(
    tools=[],
    model=HfApiModel(),
    additional_authorized_imports=['*']
)
agent.run('Use the requests library to fetch and parse the NVD feed.')

• ›Adds verbosity_level=0/1/2 parameter to agent initialization, replacing the old verbose=True/False boolean for finer-grained log control.
• ›Enables unrestricted code-sandbox imports via additional_authorized_imports=['*'] on agent initialization.
• ›Adds OpenTelemetry instrumentation support for tracing and inspecting agent runs.
• ›Adds multi-GPU support for TransformersModel.
• ›Adds file upload capability to GradioUI.

smolagents v1.2.0 adds OpenAIServerModel, OpenTelemetry observability, Hugging Chat integration, and halves import time by dropping torch.

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

from smolagents import OpenAIServerModel

model = OpenAIServerModel(
    model_id="meta-llama/Llama-3-8b-instruct",
    api_base="http://localhost:8000/v1",
    api_key="none"
)

• ›Adds OpenAIServerModel class, enabling use of any OpenAI-format-compatible inference server (TGI, vLLM, etc.) as a model backend.
• ›Simplifies the Model base class to a single __call__ method: passing tools_to_call_from returns a tool call; omitting it returns a plain string.
• ›Adds OpenTelemetry support for agent observability and tracing.
• ›Integrates smolagents tools into Hugging Chat, enabling agent tool use directly from the chat interface.
• ›Halves library import time by removing the torch dependency.

smolagents v1.1.0 adds max_results to DDGS tool, device param for TransformerModel, and broader LiteLLMModel kwargs support.

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

• ›Adds max_results keyword argument to the DDGS (DuckDuckGo Search) tool to control the number of results returned.
• ›Adds device parameter to TransformerModel in models.py for explicit device placement.
• ›Adds support for additional keyword arguments (kwargs) in LiteLLMModel, enabling pass-through of provider-specific options.
• ›Adds a warning to CodeAgent when required imports are missing at runtime.

Aider v0.72.0 adds DeepSeek R1 support, Kotlin repo-map parsing, and configurable line endings.

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

$ aider --model r1

$ aider --model openrouter/deepseek/deepseek-r1

• ›Supports DeepSeek R1 via --model r1 shortcut or OpenRouter with --model openrouter/deepseek/deepseek-r1.
• ›Adds Kotlin syntax support to the repo map for accurate code context.
• ›New --line-endings flag controls line-ending style when writing files.
• ›Adds read-only file announcements so practitioners can see which files Aider will not modify.

Aider v0.71.0 adds custom voice device settings, doubles chat history limit, and makes bare mode-switch commands easier.

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

$ /ask
# ... ask questions ...
/code
# ... request edits ...
/architect

• ›Bare /ask, /code, and /architect commands now switch the active chat mode without requiring additional arguments.
• ›Increases max chat history tokens from 4k to 8k, enabling longer context for complex sessions.
• ›Increases default repomap size for broader codebase awareness.
• ›Adds support for custom voice format and input device settings.
• ›Adds token count feedback when adding command output to chat.

Cline v3.2.0 adds Plan/Act mode, VS Code LM API provider, and per-tool MCP auto-approve controls.

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

• ›New Plan/Act mode toggle: Plan mode lets Cline gather information and design a solution before switching to Act mode for execution.
• ›New popup menu under the chat field for switching between API providers and models without leaving the conversation.
• ›Adds VS Code LM API provider, enabling use of models supplied by other VS Code extensions such as GitHub Copilot.
• ›Adds on/off toggle for individual MCP servers and per-tool auto-approve settings within MCP servers.

Cline v3.1.0 adds workspace checkpoints with diff/restore, a post-task change summary, and per-task disk-usage tracking.

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

• ›Adds workspace checkpoints: every tool use snapshots the workspace so you can Compare (diff vs. current state) or Restore (task+workspace, task only, or workspace only) at any hover point.
• ›Adds a 'See new changes' button on task completion, giving a consolidated diff overview of all workspace changes since the last 'Task Completed' — useful when Auto-approve is enabled.
• ›Adds per-task disk-usage display and a delete button so you can manage the git-backed checkpoint storage consumed by each task.

Goose v1.0.3 adds a CONFIGURE=false install option and Ollama host configuration support.

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

$ CONFIGURE=false curl -fsSL https://github.com/block/goose/releases/latest/download/install.sh | bash

• ›Adds CONFIGURE=false option to the install script to skip interactive configuration during automated or scripted installs.
• ›Supports setting a custom Ollama host, enabling Goose to connect to remote or non-default Ollama instances.
• ›Updates the UI to expose Ollama host configuration directly in the interface.

OpenHands 0.21 adds trajectory replay, downloadable trajectories, multi-language UI, and a dedicated draft-editor LLM config.

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

• ›Adds multi-language UI support, broadening accessibility for non-English practitioners.
• ›Supports the reasoning_effort parameter for OpenAI o1-family models, giving control over model reasoning depth.
• ›Introduces a draft_editor named custom LLM config so a separate, dedicated model can handle edit drafts independently of the primary LLM.
• ›Adds trajectory replay in headless mode, enabling automated re-execution of recorded agent sessions.
• ›Adds a chat-panel button to download the current agent trajectory for offline review or auditing.

OpenHands 0.20.0 adds a live App tab for interacting with web apps and a conversation info display.

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

• ›Adds a new App tab (Beta) that lets users interact directly with the web app running inside OpenHands.
• ›Displays current conversation info in the bottom-right corner of the UI.

OpenHands 0.19.0 adds custom microagents in headless/CLI modes, toggleable function calling, multi-conversation support, and runtime size configuration.

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

• ›Supports custom microagents in headless and CLI modes, extending agent customization beyond the UI.
• ›Enables or disables function calling via user configuration, giving practitioners control over LLM tool-use behavior.
• ›Adds rate-limit error visibility in the UI and agent state, surfacing provider throttling in real time.
• ›Introduces multi-conversation feature (behind a feature flag), allowing parallel conversation management.
• ›Adds runtime size configuration, letting users tune the sandbox compute footprint per session.

OpenHands 0.18.0 adds per-repo prompt customization, resizable panels, and server-side settings storage.

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

• ›Adds .openhands directory support for customizing agent prompts on a per-repository basis.
• ›Introduces a resizable and collapsible panel layout in the UI for a more flexible workspace.
• ›Enables workspace downloads on mobile and browsers lacking the Directory API.
• ›Migrates settings storage from browser localStorage to the server API, enabling persistent settings across devices and browsers.
• ›Adds navbar tooltips for improved UI discoverability.

Zed v0.170.1 adds LM Studio AI support, vim-sneak, SubWord TextObject, and a new project_panel.entry_spacing setting.

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

{
  "project_panel": {
    "entry_spacing": "standard"
  }
}

[
  {
    "context": "VimControl",
    "bindings": {
      "s": "vim::Sneak",
      "S": "vim::SneakBackward"
    }
  }
]

[
  {
    "context": "Diagnostics",
    "bindings": {
      "r": "diagnostics::Deploy"
    }
  }
]

• ›Adds project_panel.entry_spacing setting to configure project panel entry spacing; accepted values are comfortable (default) or standard.
• ›Adds Diagnostics key context to enable Diagnostics pane-specific keybindings in keymap config.
• ›Adds LM Studio as a supported AI provider in the Assistant.
• ›Adds vim-sneak plugin emulation via the Sneak and SneakBackward operators (disabled by default; must be enabled by binding a key).
• ›Adds SubWord TextObject in Vim mode.

Zed v0.169.2 adds workspace::OpenFiles, fine-grained scrollbar diagnostics, Gemini 2.0 Flash, Claude 3.5 Haiku, and new Vim/Emacs keybinds.

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

{
  "context": "Workspace",
  "bindings": {
    "alt-z": ["app_menu::OpenApplicationMenu", "Zed"],
    "alt-f": ["app_menu::OpenApplicationMenu", "File"],
    "alt-e": ["app_menu::OpenApplicationMenu", "Edit"],
    "alt-s": ["app_menu::OpenApplicationMenu", "Selection"],
    "alt-v": ["app_menu::OpenApplicationMenu", "View"],
    "alt-g": ["app_menu::OpenApplicationMenu", "Go"],
    "alt-w": ["app_menu::OpenApplicationMenu", "Window"],
    "alt-h": ["app_menu::OpenApplicationMenu", "Help"]
  }
}

• ›Adds workspace::OpenFiles action to enable opening individual files on Linux and Windows.
• ›Adds app_menu::OpenApplicationMenu action with keyboard navigation for menus on Linux, bindable via the user keymap.
• ›Adds fine-grained control of scrollbar diagnostic indicators.
• ›Adds support for Google's Gemini 2.0 Flash experimental model.
• ›Adds support for the Claude 3.5 Haiku model.

Zed v0.168.3 adds auto-focus for the docked terminal on load when no other item is focused.

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

• ›Adds auto-focus for the docked terminal on load when no other item is focused.

Zed v0.168.2 adds Linux menus, sticky multibuffer headers, OpenAI o1 Copilot support, and new vim/terminal capabilities.

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

• ›Adds workspace::ToggleRightDock behavior change: now opens the assistant panel when no right-dock panel has previously been activated.
• ›Adds terminal::ToggleViMode action (bound by default to ctrl-shift-space) to enable Alacritty vi-mode arrow key movement across more keyboard layouts in the Zed terminal.
• ›Adds keybinds cmd-k e / cmd-k t (macOS) and ctrl-k e / ctrl-k t (Linux) for 'Close Left' / 'Close Right' tab actions.
• ›Adds support for OpenAI o1 model (non-preview) in GitHub Copilot Chat.
• ›Adds block comment syntax <!-- and --> for Markdown files.

Zed v0.167.1 adds multibuffer folding, task center-pane targeting, new settings for scroll/tabs/hover, and simultaneous inline+menu completions.

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

// In keymap.json
{
  "bindings": {
    "ctrl--": ["task::Spawn", { "task_name": "echo hello", "target": "center" }]
  }
}

{
  "hover_popover_delay": 600,
  "lsp_highlight_debounce": 200,
  "max_tabs": 10,
  "horizontal_scroll_margin": 4,
  "scrollbar": { "axis": "vertical" }
}

• ›Adds target: 'center' parameter to task::Spawn keybinding action, allowing tasks launched via custom keybindings to open in the center pane.
• ›Adds hover_popover_delay setting to control the delay before hover boxes appear.
• ›Adds lsp_highlight_debounce setting to configure the delay for querying highlights from a language server.
• ›Adds horizontal_scroll_margin and scrollbar.axis settings for scroll behavior control.
• ›Adds max_tabs setting to limit the maximum number of open tabs.

KoboldCpp v1.81.1 adds local WebSearch augmentation via DuckDuckGo, a heuristic chat-template guesser, and browser-based RAG via TextDB.

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

$ koboldcpp.exe --model mymodel.gguf --websearch

• ›Adds --websearch CLI flag (and GUI toggle) to enable KoboldCpp as a local WebSearch proxy, powered by DuckDuckGo, augmenting model queries with live web results.
• ›Adds /api/extra/websearch endpoint for submitting web-search-augmented queries directly to the running KoboldCpp instance.
• ›Adds TextDB Document Lookup in Kobold Lite (Context > TextDB tab), a browser-based RAG layer using lunr/minisearch to chunk, store, and retrieve relevant snippets from a pasted text document at inference time — no embedding model required.
• ›Switches Kobold Lite autosaves and save slots from localStorage to indexedDb, significantly increasing the maximum supported browser save size; existing localStorage data is auto-migrated on first launch.
• ›Expands supported resolutions and aspect ratios for generated and uploaded images, and improves multimodal image handling quality for larger, more detailed images.

oobabooga text-gen v2.3 cuts Chat tab CPU usage via morphdom incremental rendering and adds per-message copy/regenerate buttons.

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

• ›Adopts the morphdom library for incremental DOM updates in the Chat tab during streaming, drastically reducing CPU usage on long contexts or high token throughput and keeping the UI responsive.
• ›Enables text and code selection/copying from previous chat messages while a reply is still streaming, since only changed elements are updated.
• ›Adds a 'copy raw message content' button below each chat message.
• ›Adds a 'regenerate reply' button below the last chat message.
• ›Activates auto_max_new_tokens by default, removing the need to manually continue replies every 512 tokens.

oobabooga textgen v2.2 adds branch/search chat UI, --torch-compile, --exclude-pattern, IPv6 API support, and ExLlamaV2 sampler expansions.

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

$ python server.py --torch-compile

$ python download-model.py TheBloke/Mixtral-8x7B-v0.1-GGUF --exclude-pattern '*.Q8_0.gguf'

• ›Adds --torch-compile flag for the transformers loader to improve inference performance.
• ›Adds --exclude-pattern flag to the download-model.py script to filter files during model downloads.
• ›Connects XTC, DRY, smoothing_factor, and dynatemp sampling parameters to the ExLlamaV2 loader (non-HF).
• ›Adds IPv6 support to the API.
• ›Adds a 'Static KV cache' option for transformers to improve performance.

Ollama v0.5.5 adds 8 new models including DeepSeek-V3 and Phi-4, plus a faster /api/create endpoint that now accepts JSON.

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

• ›Adds Phi-4 (14B, Microsoft) to the model library.
• ›Adds Command R7B (Cohere) for efficient inference on commodity GPUs and edge devices.
• ›Adds DeepSeek-V3, a 671B MoE model with 37B parameters activated per token.
• ›Adds OLMo 2 (7B and 13B) trained on up to 5T tokens.
• ›Adds Dolphin 3, a general-purpose instruct-tuned model supporting coding, math, agentic, and function-calling use cases.

Phoenix v7.9.0 adds support for OpenAI o1 developer messages and the reasoning parameter.

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

• ›Adds support for o1 developer messages and the reasoning parameter in OpenAI o1 model integrations.

Phoenix 7.8.0 improves error visibility with prettified user-facing mutation error messages.

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

• ›Improves user-facing error display for GraphQL mutations, making error messages more readable in the UI.

Phoenix Evals 0.19.0 adds audio evaluation support to llm_classify().

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

• ›Adds audio evals and a data processor to llm_classify(), enabling evaluation of audio-based LLM inputs.

Arize Phoenix 7.7.0 adds experiment run filtering on the compare experiments page.

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

• ›Adds experiment run filter to the compare experiments page, enabling side-by-side comparison of specific runs across experiments.

Phoenix playground now supports anyOf JSON schema for structured output definitions.

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

• ›Adds anyOf JSON schema support in the playground for defining structured LLM outputs.

Phoenix v7.4.0 adds a token breakdown view in the project header UI.

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

• ›Shows a breakdown of tokens in the project header for at-a-glance token usage visibility.

Langfuse v3.22.0 adds a native OpenTelemetry traces ingestion endpoint and a quick-access cmd+k command menu.

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

• ›Adds otel/v1/traces endpoint to accept OpenTelemetry spans directly, enabling native OTEL trace ingestion without a separate collector.
• ›Adds cmd+k keyboard shortcut to open the command menu from the main UI navigation.

Langfuse v3.21.0 adds CodeMirror-powered prompt variable highlighting and linting in the UI.

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

• ›Adds CodeMirror editor for text area input in the prompt UI, with syntax highlighting and linting of prompt variables.
• ›Adds a customizable CodeMirror theme for the editor UI.

Langfuse v3.20.0 adds cmd+k project/org switching and independent prompt version scrolling in the UI.

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

• ›Enables switching between projects and organizations directly from the cmd+k menu.
• ›Allows scrolling through prompt versions independently from the prompt itself in the Prompts UI.
• ›Automatically scrolls the selected prompt version into view in the Prompts UI.

Langfuse v3.19.0 adds commit messages for prompts, a cmd+k command menu, and LANGFUSE_INIT_PROJECT_RETENTION env var for initializing data retention.

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

• ›Adds LANGFUSE_INIT_PROJECT_RETENTION environment variable to set data retention on project initialization (self-host enterprise).
• ›Adds commit_message field support to prompts, letting teams annotate prompt versions with a description of what changed.
• ›New cmd+k command menu in the UI for quick keyboard-driven navigation.
• ›Allows removing the system message directly in the messages UI.
• ›Data retention feature exits beta and is now available to self-hosted enterprise plans.

Langfuse v3.17.1 adds automatic removal of ClickHouse data beyond the configured retention limit.

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

• ›Automatically removes data beyond the retention limit from ClickHouse, enforcing data lifecycle policies at the storage layer.

Langfuse v3.17.0 adds configurable auth checks and SSO provider methods.

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

• ›Adds configurable authentication checks and auth method selection across SSO providers.

Langfuse v2.95.0 makes SSO auth checks and auth methods configurable per provider.

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

• ›Adds configurable checks and auth method settings across SSO providers for more flexible identity provider integration.

Langfuse v2.94.0 adds proxy support for OAuth flows.

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

• ›Adds proxy support for OAuth authentication flows, enabling deployments behind HTTP proxies to use OAuth-based integrations.

Langfuse v3.16.0 adds proxy support for OAuth authentication flows.

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

• ›Adds proxy support for OAuth flows, enabling deployments behind an HTTP proxy to authenticate via OAuth.

Langfuse v3.15.0 adds AUTH_CUSTOM_ID_TOKEN env var, media retention deletion, time-to-first-token in trace timeline, and prompt version updates.

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

• ›Adds AUTH_CUSTOM_ID_TOKEN environment variable to support custom ID token configuration for authentication.
• ›Adds media asset deletion driven by retention settings, enabling automatic cleanup of stored media.
• ›Adds time-to-first-token metric to the trace timeline view for LLM latency visibility.
• ›Displays count of all log kinds (observations) directly on the trace table.
• ›Adds the ability to update prompt versions in the prompt management UI.

Langfuse v2.93.9 adds DATABASE_ARGS config support and a new AUTH_CUSTOM_ID_TOKEN environment variable.

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

• ›Adds DATABASE_ARGS environment variable to pass extra arguments to the database connection configuration.
• ›Adds AUTH_CUSTOM_ID_TOKEN environment variable to supply a custom ID token for authentication flows.

Langfuse v3.14.0 adds prompt diff view, prompt duplication, extra LLM API headers, and data retention config in project settings.

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

• ›Adds data retention configuration in project settings, letting teams control how long trace and observation data is stored.
• ›Supports extra headers on LLM API key configurations, enabling custom auth or routing headers for LLM provider calls.
• ›Adds a diff view when creating a new prompt version, making it easy to review changes between prompt iterations.
• ›Supports prompt duplication directly in the UI, streamlining the creation of prompt variants.
• ›Enables cloud users to switch between available subscription plans directly from the product.

Langfuse v3.13.0 adds an audit log view in project settings.

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

• ›Adds an audit log view to project settings, giving teams visibility into project-level activity.
• ›Adds product analytics events for dataset runs.

Langfuse v3.12.0 adds DATABASE_ARGS environment variable support for custom database connection parameters.

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

• ›Adds DATABASE_ARGS environment variable to pass additional configuration arguments to the database connection.

Langfuse v3.11.0 merges the generations view into a unified observations table.

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

• ›Converts the generations view into the observations table, unifying LLM call data under a single UI surface.

Langfuse v3.10.0 adds CSV dataset import, gemini-2.0-flash-exp support, and a single-user analytics view.

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

• ›Adds CSV import for uploading datasets directly via the UI.
• ›Adds playground and eval support for gemini-2.0-flash-exp.
• ›New single-user view with simplified metrics and a link to the dashboard.

Langfuse v3.9.0 adds trace observation-level filtering, hidden observation hints, and o1 model cost tracking.

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

• ›Adds minObservationlvl filter in the trace detail UI to narrow down observations by minimum level.
• ›Adds a hint in the trace tree UI when observations are hidden, improving visibility into filtered trace data.
• ›Adds cost tracking support for OpenAI o1 models in the model cost configuration.

Langfuse v3.8.0 adds streaming to observation and trace list endpoints and persists dashboard score graph selections.

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

• ›Uses streaming for observation and trace list endpoints, enabling faster and more scalable data retrieval for large result sets.
• ›Saves selected score graphs on the dashboard to localStorage on a per-project basis, so dashboard configurations persist across sessions.
• ›Shows count of group selection on column visibility controls in UI tables.

Langfuse v3.7.0 adds an 'Add to Dataset' button in annotation queues and a script to replay missing events.

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

• ›Adds an 'Add to Dataset' button directly on the trace preview inside annotation queues, streamlining dataset curation during review.
• ›Adds a script to replay missing events, enabling recovery of lost ingestion data.

Langfuse v3.6.1 adds Redis-to-Postgres queue backup, 24-hour eval retry on rate limits, and a last-used sort for the models table.

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

• ›Backs up Redis queues to Postgres to improve durability of queued work.
• ›Retries eval executions that receive 429 rate-limit errors for up to 24 hours, preventing dropped evaluations during LLM provider throttling.
• ›Adds a lastUsed column to the models table with full lookback, sortable by last-used date.

Langfuse v3.6.0 adds CLICKHOUSE_DB environment variable support for self-hosted ClickHouse configuration.

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

• ›Adds CLICKHOUSE_DB environment variable to configure the ClickHouse database name in self-hosted deployments.

Weave v0.51.31 adds Dataset construction from Calls, pandas bridging helpers, and an in-UI dataset editing interface.

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

• ›Adds helper methods to convert between pandas DataFrames and Weave datasets, bridging pandas workflows with Weave's dataset primitives.
• ›Allows Dataset to be constructed directly from Calls, enabling trace data to be turned into a dataset without manual transformation.
• ›New dataset editing UI lets users modify dataset contents directly in the browser.

Weave v0.51.30 adds autopatch opt-out support and a configurable grid page size in the UI.

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

• ›Adds the ability to disable autopatch, giving users programmatic control over whether Weave automatically patches supported integrations.
• ›Adds configurable page size in the grid view, letting users control how many rows are displayed per page.
• ›Adds Amazon Bedrock to the Weave sidebar as a tracked integration surface.

Weave v0.51.29 adds Bedrock integration, JPEG/PNG tracking, SDK object deletion, and improved ref-getting.

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

• ›Adds weave.delete (delete objects and ops from the SDK) so practitioners can programmatically remove objects and ops without going through the UI.
• ›Adds Amazon Bedrock support via a new integration, enabling tracing of Bedrock model calls.
• ›Adds support for tracking JPEG and PNG images natively, expanding logged artifact types beyond text and structured data.
• ›Improves ref-getting ergonomics, making it more convenient to retrieve references to tracked objects in the SDK.
• ›Tracks the creating user on object creation, surfacing the user column in objects and ops tables in the UI.

Weave v0.51.28 adds code redaction, global post-processing options, UI object deletion, and guardrails/monitoring via scorer application.

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

calls = client.calls(filter={'op_name': 'my_op'})
print(len(calls))

• ›Adds global post-processing options for controlling how captured data is transformed before storage.
• ›Enables call.feedback.add() for annotation-type feedback on traced calls.
• ›Supports len() on CallsIter, making iteration over call results more Pythonic.
• ›Implements public 'apply scorer' capability, the MVP foundation for Guardrails and Monitoring workflows.
• ›Adds ability to delete objects directly from the UI.

Weave v0.51.27 adds op configuration for autopatched integrations and ChatNVIDIA autopatch support in LangChain.

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

• ›Adds op configuration support for autopatched functions across remaining integrations, enabling per-function tracing customization.
• ›Adds autopatching of ChatNVIDIA in LangChain, extending Weave's automatic tracing to NVIDIA-hosted models.
• ›Creates an API client for the trace server in weave_query, enabling programmatic access to trace data.
• ›Adds a mods page and menu item for wandb admins.

Chroma 0.6.2 adds Voyage AI embedding integration and parallelized log materialization for faster segment writes.

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

• ›Adds Voyage AI embedding integration via the [ENH] Voyage Integration feature, enabling Voyage models as an embedding function.
• ›Parallelizes applying materialized log to segment writers, improving write throughput for high-volume ingestion workloads.
• ›Pipelines segment committing and flushing to reduce latency during compaction.

Chroma 0.6.1 adds MPS-accelerated OpenCLIP embeddings, HNSW integrity validation on load, and OpenTelemetry foyer metrics export.

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

• ›Exports foyer metrics via OpenTelemetry (otel), enabling observability of Chroma's internal cache layer.
• ›Validates HNSW index integrity on load, catching corrupted index state at startup rather than at query time.
• ›Supports MPS (Apple Silicon GPU) accelerated OpenCLIP embeddings, improving embedding throughput on macOS devices.

LanceDB python-v0.18.1-beta.2 adds distance_type() and metric() alias to sync query builders.

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

results = table.search(query_vector).distance_type('cosine').limit(10).to_list()

• ›Adds distance_type() parameter to Python sync query builders, plus metric() as an alias, for controlling vector distance calculations inline with query construction.

LanceDB python-v0.18.1-beta.1 adds a drop_index() method for programmatic index removal.

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

table.drop_index("index_name")

• ›Adds drop_index() method to tables, enabling programmatic removal of vector indexes.

LanceDB v0.15.1-beta.0 adds a drop_index() method and upgrades the Lance storage engine to v0.23.0-beta.2.

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

table.drop_index("vector_idx")

• ›Adds drop_index() method to tables, enabling programmatic removal of vector indexes.
• ›Upgrades the underlying Lance storage engine to v0.23.0-beta.2, incorporating the latest storage improvements.

LanceDB v0.15.0 adds hybrid search to Node/Rust SDKs, distance thresholds and ranges, multivector type, and flips default filtering to prefiltering.

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

result = await table.query().nearest_to(vector).to_polars()

• ›Adds to_polars method to AsyncQueryBase in Python, returning query results as a Polars DataFrame.
• ›Adds flatten method to AsyncQuery in Python for flattening nested query results.
• ›Supports .rerank() on non-hybrid queries in the Python Async API.
• ›Adds hybrid search to Node and Rust SDKs.
• ›Supports vector search with distance thresholds, enabling results to be filtered by a maximum distance value.

LanceDB python-v0.18.0 adds distance thresholds, multivector support, hybrid search in Node/Rust, and to_polars for async queries.

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

results = await table.search(query_vector).to_polars()
print(results)

• ›Adds .to_polars() method to AsyncQueryBase for returning async query results as Polars DataFrames.
• ›Adds .flatten() method to AsyncQuery for flattening nested struct columns in async query results.
• ›Adds .rerank() support on non-hybrid queries in the Async API.
• ›Supports vector search with distance thresholds, letting queries filter results by a maximum distance value.
• ›Supports distance range filtering in queries, enabling min/max distance bounds on vector search results.

LanceDB python-v0.18.0-beta.0 adds distance-range queries, subschema upserts, reranking on non-hybrid queries, and switches sync Python to prefiltering by default.

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

• ›Adds to_polars() method to AsyncQueryBase, enabling direct Polars DataFrame output from async queries.
• ›Adds flatten to AsyncQuery, allowing nested struct columns to be flattened in async query results.
• ›Adds .rerank() support on non-hybrid queries in the Async API, extending reranking beyond hybrid search.
• ›Supports distance range filtering in queries, letting callers bound results by minimum and maximum vector distances.
• ›Supports inserting and upserting subschemas, so partial-schema data can be written without supplying all columns.

LanceDB v0.15.0-beta.0 adds distance range queries, subschema upserts, reranking on non-hybrid queries, and switches default filtering to prefiltering.

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

results = await table.search([0.1, 0.2, 0.3]).limit(10).to_polars()

• ›Adds to_polars() method to AsyncQueryBase for returning async query results as Polars DataFrames.
• ›Adds flatten support to AsyncQuery for flattening nested struct columns in async query results.
• ›Adds .rerank() support on non-hybrid queries in the Async API, extending reranking beyond hybrid search.
• ›Adds support for distance range filtering in vector queries, enabling min/max distance bounds on ANN results.
• ›Adds support for inserting and upserting subschemas, allowing partial-schema writes without specifying all columns.

LanceDB v0.14.2-beta.0 adds hybrid search to Node and Rust SDKs, IVF_FLAT on remote tables, and vector search distance thresholds.

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

• ›Supports vector search with distance thresholds, allowing searches to filter results beyond a maximum distance cutoff.
• ›Adds IVF_FLAT index creation on remote tables, available in both the primary SDK and the Rust SDK.
• ›Adds hybrid search capability to the Node and Rust SDKs, combining vector and full-text search in a single query.

LanceDB python-v0.17.2-beta.2 adds distance threshold filtering for vector search queries.

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

• ›Supports distance thresholds in vector search, letting queries filter out results beyond a maximum distance from the query vector.

Milvus v2.4.21 adds customizable root privileges and surfaces primary field names in search/query results.

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

• ›Adds primary field names to SearchResult and QueryResults responses, making result parsing more explicit without requiring a separate lookup.
• ›Root privileges can now be customized, giving administrators finer control over built-in RBAC permissions.
• ›Accelerates bitset operations with SIMD, improving filter and expression evaluation throughput.

Milvus 2.5.3 adds a resource group API for the RESTful interface and boosts retrieve performance via bitset SIMD methods.

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

• ›Adds a resource group API for the RESTful interface, enabling programmatic resource group management over HTTP.
• ›Optimizes retrieve performance by leveraging bitset SIMD methods, unlocking faster query throughput at scale.
• ›Adds missing delete metrics, improving observability for delete operations.
• ›Uses MVCC timestamp as the guarantee timestamp when specified, enabling more precise consistency control.

Milvus 2.5.2 adds tunable maximum VARCHAR length and supports parameter type conversion in expressions.

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

• ›Adds a parameter to tune the maximum VARCHAR column length, restoring the upper limit to 65,535 characters.
• ›Supports automatic parameter type conversion for filter/query expressions, reducing the need for explicit casting.

Milvus 2.4.20 adds a YAML config param to tune the system maximum varchar length.

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

• ›Adds a YAML configuration parameter to adjust the system limit for maximum varchar length, lifting a previously hard-coded constraint.

Qdrant v1.13.0 adds GPU-accelerated HNSW indexing, runtime resharding, strict mode, and a new Has Vector filter condition.

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

• ›Adds has vector filtering condition to check whether a named vector is present on a point, enabling queries that target only partially-vectorized records.
• ›Adds strict mode to collections to restrict certain categories of operations, giving operators tighter control over collection behaviour.
• ›Allows max_optimization_threads to be set back to automatic after being manually configured.
• ›Adds GPU support for HNSW indexing, dramatically accelerating index build times.
• ›Adds runtime resharding in Qdrant Cloud, allowing the number of shards on a collection to be changed without downtime.

Qdrant v1.12.6 adds 64-bit sparse vector indices, Issues API support for limited API keys, and JSON-format logging.

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

• ›Adds JSON-format logging support, enabling structured log ingestion into SIEM and log-aggregation pipelines.
• ›Extends the Issues API to work with limited (scoped) API keys, not just full-access credentials.
• ›Supports 64-bit dimension indices for sparse vectors, lifting the previous 32-bit index ceiling for very high-dimensional sparse data.
• ›Bundles the web UI in the official Debian package, removing the need for a separate installation step on Debian-based deployments.

Composio JS SDK v0.5.5 adds account enable/disable controls, reInitiateConnection(), and appUniqueKeys support.

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

• ›Adds reInitiateConnection() method for managing and re-initiating existing connections.
• ›Adds appUniqueKeys as a replacement identifier for appName when referencing apps.
• ›Enables enabling and disabling connected accounts via the SDK.

Composio v0.6.16 adds new integration/connection APIs, Helicone caching, crypto kit agents, and renames trigger identifiers.

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

• ›Renames triggerId to triggerName and triggerInstanceId, and adds new methods for managing trigger connections via updated API schema.
• ›Adds Helicone integration for caching OpenAI responses, reducing latency and cost for AI-backed workflows.
• ›Introduces new API schema for creating integrations, initiating connections, re-initiating, and updating connections.
• ›Adds crypto kit agents for cryptocurrency-related automation use cases.

Composio v0.6.15 adds refresh_token to AuthConnectionParamsModel

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

• ›Adds refresh_token field to AuthConnectionParamsModel, exposing refresh tokens in authenticated connection parameters.

Composio v0.6.14 adds custom action support in the Vercel toolkit and updates the AutoGen tools integration.

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

• ›Supports custom actions in the Vercel toolkit, with type safety improvements.
• ›Updates AutoGen tools to a new version, refreshing the AutoGen integration.

Composio v0.6.10 adds JS agent support and custom auth delegation for runtime actions.

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

• ›Adds support for delegating custom authentication to runtime actions, enabling dynamic auth injection at execution time.
• ›Introduces JavaScript agent support (JS agents).

Composio JS v0.5.0 adds frontend framework support, new trigger APIs, and slashes bundle size from 10 MB to 400 KB.

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

await toolset.createAction({
  // ...other fields
  inputParams: z.object({
    name: z.string().optional()
  }),
  callback: async (params) => {
    const { name } = params;
    return {
      successful: true,
      data: { name: name || 'World' }
    };
  }
});

• ›Adds getTriggerInfo and getTriggerConfig methods to the trigger interface for querying trigger metadata.
• ›Exposes .apps, .actions, .triggers, and .connectedAccounts directly on toolset classes.
• ›Exposes ComposioToolset from index.ts for top-level imports.
• ›Adds a new typed API client with full type definitions.
• ›All errors are now instances of ComposioError, each carrying an error.error_code property for programmatic debugging.