The AI Toolchain — issue -369, February 28, 2025

Agno v1.1.6 adds support for Claude 3.7 Sonnet and extended thinking in messages.

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

• ›Adds support for the Claude 3.7 Sonnet model, including extended thinking in messages.

Agno v1.1.5 adds audio responses, image understanding for XAI/Together.ai, Webex messaging, and Upstash vector DB support.

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

from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.utils.audio import write_audio_to_file

agent = Agent(
    model=OpenAIChat(
        id="gpt-4o-audio-preview",
        modalities=["text", "audio"],
        audio={"voice": "alloy", "format": "wav"},
    ),
)
agent.print_response("Tell me a 5 second story")
if agent.run_response.response_audio is not None:
    write_audio_to_file(
        audio=agent.run_response.response_audio.base64_audio,
        filename="response.wav"
    )

• ›Adds audio response support (streaming and non-streaming) via agent.run_response.response_audio, using OpenAIChat with id='gpt-4o-audio-preview' and the modalities and audio parameters; audio data is available as response_audio.base64_audio and can be written to file with write_audio_to_file().
• ›Adds image understanding support for XAI and Together.ai model providers, enabling multimodal agents on those backends.
• ›Adds a Webex integration tool for sending messages via Webex.
• ›Adds Upstash as a supported vector database backend.
• ›Adds Grounding and Search support for Gemini models to improve response accuracy and recency.

Agno v1.1.4 adds get_emails_by_thread and send_email_reply methods to GmailTools

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

from agno.tools.gmail import GmailTools

tools = GmailTools()
thread = tools.get_emails_by_thread(thread_id="<thread_id>")
tools.send_email_reply(thread_id="<thread_id>", message="Thanks, I'll follow up shortly.")

• ›Adds get_emails_by_thread and send_email_reply methods to GmailTools, enabling agents to read full email threads and reply inline.
• ›Adds metadata support to OpenAIChat.

Agno v1.1.2 adds o3 model reasoning support and migrates GeminiEmbedder to Google's new genai SDK

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

embeddings = GeminiEmbedder("text-embedding-004").get_embedding(
    "The quick brown fox jumps over the lazy dog."
)

• ›Updates GeminiEmbedder to use Google's new genai SDK, dropping the models/ prefix from model IDs (e.g. 'text-embedding-004' instead of 'models/text-embedding-004').
• ›Adds reasoning support for OpenAI's o3 models.

Agno v1.1.1 adds file/image uploads to Agent UI, MP3 support in ModelsLabTools, and custom Firecrawl API URLs.

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

• ›Adds MP3 to the FileType enum in ModelsLabTools, with API routing via MODELS_LAB_URLS and MODELS_LAB_FETCH_URLS dicts keyed by MP3, MP4, and GIF — enabling audio generation calls alongside existing video/GIF generation.
• ›Adds support for a custom API URL parameter in the Firecrawl integration, letting users point the tool at self-hosted or alternate Firecrawl endpoints.
• ›Agent UI now supports file and image uploads alongside prompts, accepting .pdf, .csv, .txt, .docx, .json (files) and .png, .jpeg, .jpg, .webp (images).

Agno v1.1.0 overhauls model support with Azure AI Foundry, full AWS Bedrock coverage, Google SDK Gemini, and exponential-backoff retries.

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

from agno.agent import Agent
from agno.models.openai import OpenAIChat

agent = Agent(
    model=OpenAIChat(id='gpt-4o'),
    exponential_backoff=True,
)
agent.print_response('Summarize the latest AI research trends.')

• ›Enables optional exponential backoff retries on model failures (e.g. rate-limit errors) when exponential_backoff is set to True on an agent.
• ›Expands AWS Bedrock support to all Bedrock models through a rewritten AwsBedrock implementation (note: AwsBedrock does not support async-await).
• ›Switches the Gemini implementation to Google's genai SDK (v1.0.0), enabling better feature parity and easier future Gemini integrations.
• ›Adds Exa Answers capability support via ExaTools.
• ›Renames GoogleSearch to GoogleSearchTools for consistency across the toolset.

Agno v1.0.8 adds Perplexity model support, a Todoist toolkit, JSON knowledge-base reader, Weaviate vector DB, Google Sheets tool, and custom retriever support.

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

from agno.models.perplexity import Perplexity
from agno.agent import Agent

agent = Agent(model=Perplexity())
agent.print_response('What are the latest developments in AI safety?')

from agno.tools.todoist import TodoistTools
from agno.agent import Agent

agent = Agent(tools=[TodoistTools()])
agent.print_response('Add a task to review the quarterly report by Friday.')

• ›Adds Perplexity as a model provider, enabling agents to use Perplexity AI models.
• ›Adds a Todoist toolkit for managing tasks from within agents.
• ›Adds a JSON file reader for loading JSON files into knowledge bases.
• ›Adds name_exists function to the LanceDB vector store integration.
• ›Adds async support for Mistral model provider.

Agno v1.0.7 adds Google Sheets toolkit, Weaviate vector store, and async support for Mistral and Cohere

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

• ›Mistral now supports async execution via agent.arun() and agent.aprint_response().
• ›Cohere now supports async execution via agent.arun() and agent.aprint_response().
• ›Adds a new Google Sheets toolkit for reading, creating, and updating Google Sheets.
• ›Adds Weaviate as a supported vector store backend.

Agno v1.0.6 adds a Google Maps toolkit and a URL reader/knowledge base for document ingestion.

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

• ›New Google Maps toolkit covering business discovery, directions, navigation, geocoding, and nearby-places lookup.
• ›New URL reader and knowledge base that fetches any URL and stores its text contents in the document store.

Agno v1.0.5 adds Gmail tools, Mistral vision support, Claude async, and Exa find_similar

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

from agno.tools.exa import ExaTools

exa = ExaTools()
results = exa.find_similar('https://example.com/threat-report')

• ›Adds find_similar method to ExaTools for similarity-based search.
• ›Adds a Gmail toolkit with tools for mail search, sending mail, and related operations.
• ›Enables async usage of Claude models via await agent.aprint_response() and await agent.arun(), including async tool calls.
• ›Adds Mistral vision model support.

AutoGPT Platform v0.4.10 adds an XML Parser Block, RabbitMQ messaging, batch text extraction, and version-aware agent scheduling.

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

• ›Adds a new XML Parser Block for parsing XML data within agent workflows.
• ›Adds batch matched result and count output to the ExtractTextInformationBlock, enabling bulk text extraction results in a single pass.
• ›Integrates RabbitMQ into the Docker Compose setup and attaches it to the AppService for message-queue-backed agent execution.
• ›Enables scheduling of a specific agent version, giving operators control over which version runs on a schedule.
• ›Supports opening graphs by version and execution ID, allowing direct deep-linking into a specific agent run.

AutoGPT Platform v0.4.9 enhances external API output for agent results.

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

• ›Enhances output from the external API on agent output, improving the data returned when retrieving agent results programmatically.

AutoGPT Platform adds Todoist integration blocks, ScreenshotOne block, text replace block, and user credit transaction history.

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

• ›Adds Todoist REST API blocks with OAuth authentication, enabling Todoist task and project management as automation steps.
• ›Adds a ScreenshotOne block for capturing web screenshots within automation workflows.
• ›Adds a text replace block for string substitution operations inside agent pipelines.
• ›Adds user credit transaction history, giving users visibility into platform credit usage over time.
• ›Updates available LLM models in the platform model selector.

DSPy 2.6.5 adds multitenancy support for Weaviate vector store integration.

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

• ›Adds multitenancy support to the Weaviate integration, enabling tenant-isolated retrieval in multi-tenant Weaviate deployments.

DSPy 2.6.3 adds status streaming support and context truncation for ReAct agents

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

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

DSPy 2.6.2 adds the InferRules optimizer and multimodal example support with dspy.Image.

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

• ›Adds InferRules optimizer for automated rule inference during prompt optimization.
• ›Supports arbitrary dspy.Image objects inside DSPy examples, enabling multimodal training and optimization workflows.

DSPy 2.6.1 adds o3-mini support, separates in-memory cache from LiteLLM, and lets production deployments skip history writes.

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

$ DSP_CACHEBOOL=false python my_dspy_app.py

import dspy
lm = dspy.LM('openai/o3-mini')
dspy.configure(lm=lm)

• ›Adds DSP_CACHEBOOL environment variable support: setting it to false skips cache initialization entirely.
• ›Separates DSPy's in-memory cache from the LiteLLM cache, giving independent control over each layer.
• ›Adds a new option to disable DSPy's write-to-history behavior for production deployments where history tracking is unwanted.
• ›Moves the default joblib cache directory into .dspy_cache for cleaner local storage layout.
• ›Adds support for o3-mini and other OpenAI reasoning models in the lm module.

langchain-openai 0.3.7 adds global SSL context support, Pydantic model serialization in messages, and auto-upgrades o-series system role to 'developer'.

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

• ›Adds global SSL context configuration for OpenAI client connections.
• ›Supports serialization of Pydantic models inside messages, enabling structured message content to round-trip correctly.
• ›Automatically maps the system role to developer for o-series models, aligning with OpenAI's updated role conventions.
• ›Adds BaseMessage.text() method to core for extracting plain-text content from a message object.

langchain-core 0.3.38 defaults astream_events to v2 and adds pydantic model serialization in messages

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

async for event in chain.astream_events(input):
    print(event)

• ›Sets version="v2" as the default in astream_events, removing the need to pass the version argument explicitly.
• ›Supports serialization of pydantic models in messages, enabling pydantic objects to round-trip through message payloads.
• ›Returns a ToolMessage from tools when the tool call ID is an empty string, expanding handling of edge-case tool call responses.
• ›Adds SambaNova chat models to the load module mapping, enabling deserialization of SambaNova-backed runnables.

MistralAIEmbeddings gains async support, batching, concurrency controls, and new output type options.

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

from langchain_mistralai import MistralAIEmbeddings
import asyncio

embeddings = MistralAIEmbeddings(
    model="mistral-embed",
    batch_size=64,
    max_concurrent_requests=16,
    max_retries=3,
    timeout=60,
    output_type="binary",
)

docs = ["Threat actor exfiltrated credentials via S3.", "Lateral movement detected on host-42."]
vectors = asyncio.run(embeddings.aembed_documents(docs))

• ›Adds batch_size (default: 32), max_retries (default: 5), timeout (default: 120), max_concurrent_requests (default: 64), wait_time (default: 0.5), and dimensions fields to MistralAIEmbeddings for fine-grained control over embedding requests.
• ›Adds output_type field to MistralAIEmbeddings to select embedding format — supported values include 'float', 'binary', and 'ubinary'.
• ›Adds aembed_documents() and aembed_query() async methods to MistralAIEmbeddings, backed by concurrent request processing via asyncio.Semaphore.

langchain-community 0.3.18 adds image search, structured ChatPerplexity, Jina API key support, and new retriever/store parameters.

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

from langchain_community.retrievers import NeedleRetriever

retriever = NeedleRetriever(needle_api_key="<key>", collection_id="<id>", top_k=5)
docs = retriever.get_relevant_documents("What is our refund policy?")

• ›Adds top_k parameter to the Needle Retriever for controlling result count.
• ›Adds IN operator support to AzureCosmosDBNoSQLVectorStore for richer vector store queries.
• ›Adds configurable text_key parameter to Pinecone Hybrid Search for both indexing and retrieval.
• ›Adds API key parameter to the Jina Search API Wrapper for authenticated requests.
• ›Adds image support to DuckDuckGoSearchAPIWrapper, enabling image search results.

LangChain Core 0.3.36 lets tools accept a raw JSON schema as args_schema.

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

• ›Allows passing a raw JSON schema directly as args_schema when defining tools, in addition to the previously required Pydantic model.

langchain-xai 0.2.1 adds dedicated structured output support for xAI models.

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

• ›Adds dedicated structured output feature for xAI models, enabling native structured response handling rather than prompt-based workarounds.

init_chat_model gains xAI and IBM WatsonX AI support, plus automatic o3 model-string inference for OpenAI.

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

from langchain.chat_models import init_chat_model
model = init_chat_model("o3")
model.invoke("Explain chain-of-thought prompting.")

• ›Adds xai as a supported provider in init_chat_model, enabling xAI chat models to be instantiated via the unified model factory.
• ›Infers o3 model strings passed to init_chat_model as OpenAI models automatically, removing the need to specify the provider explicitly.
• ›Adds support for IBM WatsonX AI chat models via init_chat_model.

langchain-openai 0.3.6 enables streaming support for OpenAI o1 models.

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

• ›Enables streaming for o1 models in langchain-openai.

langchain-openai 0.3.5 makes parallel_tool_calls an explicit keyword argument on bind_tools.

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

• ›Adds parallel_tool_calls as an explicit keyword argument to bind_tools, replacing implicit pass-through behavior.

langchain-community 0.3.17 adds GPU support for FastEmbedEmbeddings, operator filters for Supabase, and OCI auth file location option.

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

• ›Adds auth_file_location option to the OCI Generative AI integration, allowing callers to specify a custom auth file path.
• ›Adds operator filter support for Supabase vector search, enabling more expressive query filtering.
• ›Adds GPU support for FastEmbedEmbeddings, including ONNX execution provider configuration for GPU-accelerated embedding inference.
• ›Adds standard tests for the Perplexity integration.
• ›Refactors the PDFMiner and PyPDF parsers in the community package.

HTMLHeaderTextSplitter now uses BeautifulSoup instead of lxml/XSLT for improved large HTML file processing.

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

• ›Replaces lxml and XSLT with BeautifulSoup in HTMLHeaderTextSplitter for improved processing of large HTML files.

LangChain Core 0.3.34 lets you pass raw message dicts directly into ChatPromptTemplate.

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

• ›Adds support for passing message dicts directly into ChatPromptTemplate, removing the need to convert dicts to message objects before building prompts.

LangChain Community 0.3.17rc1 adds operator filter support for Supabase and an auth file location option for OCI Generative AI.

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

• ›Adds auth_file_location option to the OCI Generative AI integration, allowing authentication credentials to be loaded from a file path.
• ›Adds operator filter support for the Supabase vector store integration.

New langchain-deepseek package adds ChatDeepSeek integration and init_chat_model support for DeepSeek models.

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

from langchain.chat_models import init_chat_model
llm = init_chat_model(model="deepseek-chat", model_provider="deepseek")

from langchain_deepseek import ChatDeepSeek
llm = ChatDeepSeek(model="deepseek-chat")
response = llm.invoke("Explain zero-trust networking in one paragraph.")
print(response.content)

• ›Adds ChatDeepSeek as a new chat model integration in the langchain-deepseek package, enabling DeepSeek models as a drop-in LangChain chat interface.
• ›Registers DeepSeek as a named provider in LangChain's init_chat_model, allowing model instantiation by provider string alongside existing providers.

LangGraph 0.2.75 adds structured response support and configuration schemas to the ReAct agent executor.

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

from langgraph.prebuilt.chat_agent_executor import AgentStateWithStructuredResponse

• ›Adds AgentStateWithStructuredResponse class to support structured responses in the ReAct agent executor.
• ›Adds configuration schema support to the ReAct agent executor.
• ›Enhances StreamMessagesHandler to track message IDs nested within input dictionaries for proper deduplication.
• ›Adds py.typed markers to package subdirectories for improved type-checking support.

LangGraph SDK 0.1.53 adds store authorization via @auth.on.store and dynamic loopback transport configuration.

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

@auth.on.store
async def authorize_store(ctx, value):
    # Allow access only if the namespace matches the authenticated user
    if ctx.user.identity not in value.get("namespace", []):
        raise Exception("Access denied")

• ›Adds @auth.on.store decorator to authorize access to storage operations, enabling per-user data access control.
• ›Adds configure_loopback_transports function and _registered_transports list for dynamic server transport configuration.
• ›Supports deferred loopback transport setup via the __LANGGRAPH_DEFER_LOOPBACK_TRANSPORT environment variable.

LangGraph CLI 0.1.72 adds Docker build-context support for parent-dir deps and new HTTP server config options including CORS and custom app mounting.

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

http:
  app: ./my_middleware_app.py:app
  cors:
    allow_origins:
      - "https://my-frontend.example.com"
    allow_methods:
      - "GET"
      - "POST"
  disable_routes:
    - assistants
    - store

• ›Supports Docker build contexts for local dependencies located in parent directories, enabling more flexible project layouts.
• ›Adds http.app config option to mount custom Starlette/FastAPI apps onto the LangGraph HTTP server.
• ›Adds options to disable specific API route groups (assistants, threads, runs, store) via HTTP configuration.
• ›Adds CORS configuration support for the LangGraph HTTP server.

LangGraph 0.2.74 stabilizes the Functional API and adds custom task submission via CONFIG_KEY_RUNNER_SUBMIT.

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

from langgraph.constants import CONFIG_KEY_RUNNER_SUBMIT

def my_submit(fn, *args, **kwargs):
    print(f"Submitting task: {fn.__name__}")
    return fn(*args, **kwargs)

graph.invoke(
    {"messages": [{"role": "user", "content": "Hello"}]},
    config={"configurable": {CONFIG_KEY_RUNNER_SUBMIT: my_submit}},
)

from langgraph.func import task, entrypoint

@task
def fetch_data(query: str) -> str:
    return f"result for {query}"

@entrypoint()
def pipeline(query: str):
    return fetch_data(query).result()

• ›Adds CONFIG_KEY_RUNNER_SUBMIT configuration key, enabling custom task submission logic in PregelRunner for flexible execution control.
• ›Promotes langgraph.func.task and langgraph.func.entrypoint decorators to stable (Beta label removed).
• ›Adds no-op fallback in get_stream_writer so callers can safely invoke the stream writer even when none is configured.

LangGraph checkpoint 2.0.15 adds get_checkpoint_metadata for standardized, filtered checkpoint metadata extraction.

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

from langgraph.checkpoint.base import get_checkpoint_metadata

metadata = get_checkpoint_metadata(config)
# metadata contains only string/int/bool/float fields, private keys excluded

• ›Adds get_checkpoint_metadata function to extract and process checkpoint metadata from a RunnableConfig, filtering out private/excluded keys and non-primitive types for consistent handling across checkpoint implementations.

PostgreSQL checkpoint savers now store richer metadata by merging configurable properties with existing and explicit metadata.

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

• ›Enriches checkpoint metadata automatically: put/aput methods on PostgresSaver, AsyncPostgresSaver, ShallowPostgresSaver, and AsyncShallowPostgresSaver now combine non-private configurable properties, existing metadata, and explicitly passed metadata into each saved checkpoint.

InMemorySaver now serializes configurable options and existing metadata into checkpoint metadata

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

from langgraph.checkpoint.memory import InMemorySaver

saver = InMemorySaver()

# config["configurable"] non-private keys and config["metadata"] are now
# automatically merged into the stored checkpoint metadata by put()
config = {
    "configurable": {
        "thread_id": "thread-42",
        "user_id": "alice",
        "__private_key": "ignored",  # filtered out
    },
    "metadata": {"session": "prod-run-1"},
}

# After graph.invoke(..., config=config), checkpoints stored by InMemorySaver
# will include thread_id, user_id, and session in their metadata.

• ›Enriches InMemorySaver.put checkpoint metadata with non-private config["configurable"] entries (keys not prefixed with __) and any existing config["metadata"] values

LangGraph SQLite checkpointers now store richer metadata including configurable fields and existing checkpoint metadata.

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

• ›Enriches checkpoint metadata in SqliteSaver.put and AsyncSqliteSaver.aput with configurable fields (excluding private __-prefixed keys) and any pre-existing metadata alongside explicitly provided metadata.

LangGraph 0.2.71 adds a destinations parameter to add_node() for visualizing routing in edgeless graphs.

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

graph.add_node("router", router_fn, destinations={"process": "to_process", "fallback": "to_fallback"})

graph.add_node("router", router_fn, destinations=("process", "fallback"))

• ›Adds optional destinations parameter to StateGraph.add_node(), accepting a dict of target-node→edge-label pairs or a tuple of node names, to declare possible routing paths for visualization.
• ›Enables NodeSpec and StateNodeSpec ends field to accept either a tuple of strings or a dict mapping destination node names to edge labels, improving graph rendering fidelity for Command-based edgeless graphs.

LangGraph Checkpoint 2.0.12 adds provider-string embedding init and renames MemorySaver to InMemorySaver.

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

from langgraph.store.base import IndexConfig

index_config = IndexConfig(
    embed="openai:text-embedding-3-small",
    dims=1536,
)

• ›Supports initializing embedding models via provider strings (e.g., "openai:text-embedding-3-small") in IndexConfig.embed, eliminating the need to manually instantiate an embeddings object.
• ›Introduces InMemorySaver as the canonical class name for the in-memory checkpoint saver, with MemorySaver retained as a backward-compatible alias.

LangGraph 0.2.70 adds parallel tool execution in ReAct agents and graph naming for multi-agent systems.

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

from langgraph.prebuilt import create_react_agent

agent = create_react_agent(
    model=model,
    tools=[search, calculator, lookup],
    version="v2",  # distributes tool calls via the Send API
)
result = agent.invoke({"messages": [{"role": "user", "content": "Compare prices and specs for X and Y"}]})

from langgraph.graph import StateGraph

builder = StateGraph(MyState)
# ... add nodes and edges ...
graph = builder.compile(name="research-agent")

from langgraph.prebuilt import create_react_agent

agent = create_react_agent(
    model=model,
    tools=[search],
    name="web-search-agent",
)

• ›Adds version parameter to create_react_agent() enabling parallel tool execution via the Send API (v2) or single-node processing (v1, default).
• ›Adds name parameter to Graph.compile(), StateGraph.compile(), and create_react_agent() to identify graphs when used as subgraphs.
• ›Automatically attaches agent name to AIMessages generated by the ReAct agent for easier identification in multi-agent workflows.
• ›Enables ToolNode to accept direct tool calls as a list of ToolCall dicts.
• ›Promotes _inject_tool_args to public method inject_tool_args on ToolNode.

Letta 0.6.29 adds user identities support with a user ID header on the identities GET request.

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

• ›Adds user identities support, enabling identity records to be associated with users in the Letta system.
• ›Passes a user ID header on the identities GET request to scope identity lookups to the calling user.

Letta 0.6.28 adds AWS Bedrock and DeepSeek as new LLM providers and maps context length for gpt-4o-mini.

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

• ›Adds AWS Bedrock and DeepSeek as supported LLM providers.
• ›Adds model-to-context-length mapping for gpt-4o-mini.

Letta 0.6.26 adds a tool-rules example notebook and patches Google Vertex support.

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

• ›Adds an example notebook demonstrating tool rules configuration.

Letta 0.6.23 adds configuration settings for multi-agent setups.

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

• ›Adds new settings to support multi-agent configuration in Letta.

Letta 0.6.22 refactors multi-agent support with API changes.

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

• ›Refactors multi-agent internals and introduces associated API changes.

AutoGen 0.4.6 adds MCP and HTTP built-in tools, Gemini auto-config, and MagenticOne text-only model support.

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

from autogen_ext.tools.mcp import StdioServerParams, mcp_server_tools

fetch_mcp_server = StdioServerParams(command="uvx", args=["mcp-server-fetch"])
tools = await mcp_server_tools(fetch_mcp_server)

agent = AssistantAgent(name="fetcher", model_client=model_client, tools=tools, reflect_on_tool_use=True)

from autogen_ext.tools.http import HttpTool

base64_tool = HttpTool(
    name="base64_decode",
    description="base64 decode a value",
    scheme="https",
    host="httpbin.org",
    port=443,
    path="/base64/{value}",
    method="GET",
    json_schema={"type": "object", "properties": {"value": {"type": "string"}}, "required": ["value"]},
)
assistant = AssistantAgent("base64_assistant", model_client=model, tools=[base64_tool])

from autogen_ext.models.openai import OpenAIChatCompletionClient

model_client = OpenAIChatCompletionClient(
    model="gemini-1.5-flash-8b",
    # api_key="GEMINI_API_KEY",
)

• ›Adds mcp_server_tools and StdioServerParams in autogen_ext.tools.mcp to connect agents to any Model Context Protocol (MCP) server (file system, Git, web fetch, etc.).
• ›Adds HttpTool in autogen_ext.tools.http for agents to call remote HTTP/REST API endpoints with a declarative JSON schema.
• ›Enables Gemini models in OpenAIChatCompletionClient without requiring manual model_info or base_url arguments.
• ›Adds text-only model support to MagenticOne (M1), allowing it to run without screenshot/vision capability.
• ›Allows the m1 CLI to read configuration from a YAML file.

AutoGen 0.4.5 adds token streaming for agents/teams, R1 reasoning output, partial-function tools, and a new CodeExecutorAgent sources parameter.

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

from autogen_core.models import UserMessage, ModelFamily
from autogen_ext.models.openai import OpenAIChatCompletionClient

client = OpenAIChatCompletionClient(
    model="deepseek-r1:1.5b",
    api_key="placeholder",
    base_url="http://localhost:11434/v1",
    model_info={"function_calling": False, "json_output": False, "vision": False, "family": ModelFamily.R1},
)
result = await client.create(messages=[UserMessage(content="Is this log line indicative of a brute-force attack?", source="user")])
print("Reasoning:", result.thought)
print("Answer:", result.content)

from functools import partial
from autogen_core.tools import FunctionTool

def query_logs(environment: str, severity: str, keyword: str) -> str:
    return f"Querying {environment} logs for {severity} events matching '{keyword}'"

prod_logs = partial(query_logs, "production", "ERROR")
tool = FunctionTool(prod_logs, description="Query production ERROR logs by keyword.")
print(tool.schema)  # schema only exposes 'keyword'

• ›Adds model_client_stream=True on AssistantAgent and the new ModelClientStreamingChunkEvent message type to stream model tokens in real time through run_stream or Console.
• ›Supports R1-style reasoning output via a new CreateResult.thought field, populated when using models in the ModelFamily.R1 family (e.g., DeepSeek-R1).
• ›Enables FunctionTool to wrap functools.partial functions, automatically excluding pre-bound parameters from the generated tool schema.
• ›Adds an optional sources parameter to CodeExecutorAgent to control which message sources it extracts code from.
• ›Adds o3 to the built-in model info registry.

PydanticAI v0.0.29 adds max_results parameter to the DuckDuckGo search tool.

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

from pydantic_ai.tools.duckduckgo import DuckDuckGoSearchTool

tool = DuckDuckGoSearchTool(max_results=5)

• ›Adds max_results parameter to the DuckDuckGo search tool to control the number of results returned per query.

PydanticAI v0.0.28 adds DuckDuckGo and Tavily search tools, exposes tool_call_id on RunContext, and broadens Anthropic image MIME support.

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

from pydantic_ai import Agent, RunContext

agent = Agent('openai:gpt-4o')

@agent.tool
async def my_tool(ctx: RunContext[None], query: str) -> str:
    call_id = ctx.tool_call_id  # new in v0.0.28
    print(f'Handling call {call_id} for query: {query}')
    return f'result for {query}'

• ›Adds tool_call_id field to RunContext, giving tool implementations access to the specific call ID during execution.
• ›Adds DuckDuckGoSearch built-in tool for agent web search without an API key.
• ›Adds TavilySearch built-in tool for agent web search via the Tavily API.
• ›Broadens accepted MIME types for ImageUrl when using Anthropic models, enabling a wider range of image formats.

PydanticAI v0.0.27 adds FallbackModel for automatic model failover

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

from pydantic_ai import Agent
from pydantic_ai.models.fallback import FallbackModel
from pydantic_ai.models.openai import OpenAIModel
from pydantic_ai.models.anthropic import AnthropicModel

model = FallbackModel(OpenAIModel('gpt-4o'), AnthropicModel('claude-3-5-sonnet-latest'))
agent = Agent(model=model)
result = agent.run_sync('Summarize this report.')
print(result.data)

• ›Adds FallbackModel class to enable automatic failover across multiple LLM backends when a model call fails.

PydanticAI v0.0.26 adds multimodal input support for agents.

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

• ›Adds multimodal input support, enabling agents to accept non-text content (e.g. images, audio) alongside text messages.

PydanticAI v0.0.25 adds InstrumentedModel with OTel/streaming support and a new GraphRun object for ergonomic agent graph traversal.

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

from pydantic_ai import Agent
from pydantic_ai.models.instrumented import InstrumentedModel
from pydantic_ai.models.openai import OpenAIModel

base_model = OpenAIModel('gpt-4o')
instrumented = InstrumentedModel(base_model)
agent = Agent(instrumented)
result = await agent.run('Summarize this document.')

• ›Adds InstrumentedModel class to wrap any model with OpenTelemetry instrumentation, using raw OTel and actual event loggers.
• ›Adds request_stream support to InstrumentedModel, enabling streaming calls alongside standard instrumented requests.
• ›Adds GraphRun object to make use of next more ergonomic when iterating agent graph execution.
• ›Adds placeholder API key support for OpenAI-compatible models, easing integration with local or third-party OpenAI-compatible endpoints.

PydanticAI v0.0.24 adds Gemini 2.0 production models and populates ModelResponse.model_name from live responses.

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

• ›Populates ModelResponse.model_name automatically from actual model responses, giving agents visibility into which model variant handled a request.
• ›Adds new Gemini 2.0 models for production use.

PydanticAI v0.0.23 adds o3 model support, OpenAI reasoning_effort param, and Gemini safety settings.

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

from pydantic_ai import Agent
from pydantic_ai.models.openai import OpenAIModel

model = OpenAIModel('o3', reasoning_effort='medium')
agent = Agent(model)
result = agent.run_sync('Explain zero-day vulnerability triage strategies.')
print(result.data)

• ›Supports reasoning_effort parameter for OpenAIModel, enabling control over reasoning depth on compatible OpenAI models.
• ›Adds o3 model support to OpenAIModel.
• ›Adds Gemini safety settings support for configuring content safety thresholds on Gemini models.

PydanticAI v0.0.22 adds new Gemini experimental models and support for locally served models without API keys.

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

• ›Supports locally served models that do not require an API key, enabling use of self-hosted LLM endpoints.
• ›Adds new Gemini experimental models to the supported model list.
• ›Ports pydantic_ai.Agent internals to use pydantic_graph as its execution backend.

Semantic Kernel .NET adds OpenAPI parameter support for schema-only definitions and promotes several Agents packages.

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

• ›Adds support for OpenAPI parameters defined with a JSON schema but without an explicit type field, broadening compatibility with non-standard OpenAPI specs.
• ›Promotes .Net Agents experimental metadata toward graduation, signaling stable API surfaces for agent-based workflows.
• ›Marks Agents.OpenAI package with a preview suffix, making its pre-release status explicit in NuGet.

Semantic Kernel dotnet-1.39.0 adds prompt execution settings to AutoFunctionInvocationContext, Process Framework with Aspire demo, and OpenAI/Azure AI tracing.

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

• ›Adds PromptExecutionSettings to AutoFunctionInvocationContext, giving function invocation filters access to the active execution settings at invocation time.
• ›Introduces the Process Framework with an Aspire demo, enabling orchestration of multi-step AI processes.
• ›Adds distributed traces for OpenAI Assistant and Azure AI agent channels, surfacing observability into agent communication.
• ›Updates the Agents templating pattern in .Net Agents, aligning agent prompt construction with current Semantic Kernel conventions.
• ›Changes Agents.Abstractions to depend on SemanticKernel.Abstractions instead of SemanticKernel.Core, reducing the package dependency footprint for agent abstractions.

Semantic Kernel 1.38.0 adds AWS Bedrock Agent, role-override for ChatCompletionAgent, and a max completion tokens parameter for Azure OpenAI.

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

var agent = new ChatCompletionAgent
{
    Name = "Analyst",
    Instructions = "You are a data analyst.",
    RoleOverride = AuthorRole.System
};

• ›Adds BedrockAgent to the .NET SDK, integrating AWS Bedrock Agent as a first-class agent type.
• ›Adds role-override support for ChatCompletionAgent, allowing callers to specify a non-default message role for agent turns.
• ›Adds a max completion tokens override parameter to the Azure OpenAI connector (AzureOpenAIPromptExecutionSettings).
• ›Promotes AllowStrictSchemaAdherence property out of experimental status, making it a stable API.
• ›Adds an option to disable automatic HTML decoding in Handlebars templates.

Semantic Kernel Python 1.21.1 adds Crew.AI as a plugin and a new AzureAIAgent.create_client convenience method.

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

async with (
    DefaultAzureCredential() as creds,
    AzureAIAgent.create_client(
        credential=creds,
        conn_str=ai_agent_settings.project_connection_string.get_secret_value(),
    ) as client,
):
    # Operational code here

• ›Adds AzureAIAgent.create_client class method for creating an AIProjectClient directly on the agent, replacing the previous construction pattern.
• ›Adds Crew.AI as a plugin, enabling Crew.AI agents to be called as Semantic Kernel plugins.

Semantic Kernel Python 1.21 adds Azure AI Agent Service, Bedrock Agent, MongoDB Atlas store, and Postgres vector search.

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

$ # From the repo root
python python/samples/getting_started_with_agents/azure_ai_agent/step1_azure_ai_agent.py

• ›Adds AzureAIAgent integration via the Azure AI Agent Service, enabling Semantic Kernel plugins to back Azure AI Agents — see getting_started_with_agents/azure_ai_agent.
• ›Adds BedrockAgent integration, exposing AWS Bedrock agents within the Semantic Kernel agent framework — see samples/concepts/agents/bedrock_agent.
• ›Adds vector search support to the Postgres connector.
• ›Implements a MongoDB Atlas vector store connector.
• ›Allows the Azure AI Inference connector to target Azure AI Services resources (not only standalone inference endpoints).

Semantic Kernel .NET 1.37.0 updates OpenAI connectors to 2.2.0-beta.1 and migrates Prompty support to prompty.core

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

• ›Updates {Azure}OpenAI connectors to the latest 2.2.0-beta.1 SDK release.
• ›Migrates Prompty support to use the prompty.core package.
• ›Adds Copilot agent plugins demo samples.

Semantic Kernel 1.36.1 adds audio content support for the Gemini connector.

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

• ›Adds audio content capabilities to the Gemini connector, enabling audio input/output handling via AudioContent in .NET.

Semantic Kernel .NET 1.36.0 adds CrewAI plugin, graduates OpenAPI package, and introduces agent content allow-lists with improved tracing.

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

• ›Introduces ChatCompletionAgent allow-list of supported content types, letting callers restrict which content kinds the agent may process.
• ›Adds a CrewAI plugin integration, enabling Semantic Kernel agents to interoperate with CrewAI workflows.
• ›Graduates the OpenAPI package out of preview, making Microsoft.SemanticKernel.Plugins.OpenApi a stable dependency.
• ›Adds distributed traces for Agent invocations, surfacing per-call observability data in connected tracing backends.
• ›Updates agent logs to include the agent name, making multi-agent log streams easier to distinguish.

browser-use 0.1.37 adds file-upload-via-dict, PDF streaming, extra Chromium args support, and improved DOM processing.

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

• ›Adds extra_chromium_args support for real browser sessions, enabling custom Chromium launch flags.
• ›Supports file uploads specified as a dictionary (Feature/file upload dict), expanding how files can be passed to browser actions.
• ›Adds a function to stream PDF files from the browser context.
• ›Detects whether page.evaluate() works properly, surfacing compatibility issues with restricted browser environments.
• ›Generates unique file names automatically when a target file already exists, preventing silent overwrites.

browser-use 0.1.33 adds sensitive data handling, LLM-based page extraction, and screenshots in AgentHistory regardless of vision mode

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

• ›Captures screenshots in AgentHistory even when use_vision=False, enabling visual replay of agent runs without vision-mode overhead.
• ›Adds LLM-based page extraction, allowing the agent to extract structured content from pages using a language model.
• ›Adds sensitive data handling to prevent secrets and credentials from leaking into agent logs or prompts.
• ›Adds an Azure OpenAI integration example covering UI and model configuration.

camel v0.2.20 adds Moonshot, SiliconFlow, and AIML model integrations plus SemanticScholar and SymPy toolkits

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

• ›Adds SemanticScholarToolkits to integrate Semantic Scholar academic search into agents.
• ›Integrates Moonshot models into camel's model platform support.
• ›Integrates SiliconFlow model platform.
• ›Integrates AIML model platform.
• ›Adds SymPy integration for symbolic mathematics computation within agents.

smolagents v1.8.0 adds agent tree visualization, simplified managed agents via name/description attributes, and Open Deep Research.

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

from smolagents import CodeAgent, HfApiModel

model = HfApiModel()
sub_agent = CodeAgent(tools=[], model=model, name='researcher', description='Searches and summarizes web content')
orchestrator = CodeAgent(tools=[sub_agent], model=model)

• ›Agents now accept name and description attributes directly to function as managed agents, replacing the removed ManagedAgents class.
• ›New visualization method to display an agent's structure as a tree.
• ›Releases Open Deep Research as a built-in example/capability.

Cline v3.3.0 adds .clineignore, Plan/Act keyboard shortcut, auto-retry, and new AI providers.

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

$ # .clineignore
.env
.env.*
secrets/
config/credentials.yaml
**/*.pem

• ›New .clineignore file support lets you block Cline from accessing specified file patterns — critical when using auto-approve with sensitive files.
• ›Adds keyboard shortcut (CMD + Shift + A) to toggle between Plan and Act mode.
• ›Adds automatic intelligent retry for rate-limited requests.
• ›Adds support for AWS Bedrock profiles as a provider.
• ›Adds support for Requesty, Together, and Alibaba Qwen as new providers.

Goose v1.0.9 adds an experiment manager for feature flags and consolidates settings config.

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

• ›Adds an experiment manager to control whether individual features are enabled.
• ›Consolidates Goose settings into a unified config.
• ›Adds a default value for the OpenAI host configuration.

Goose v1.0.8 adds a new info command, customizable system prompt templates, OpenAI org/project support, reasoning effort control, and configurable OpenAI host.

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

$ goose info

• ›New goose info command displays all directories in use and current configuration at a glance.
• ›Adds a fully customizable system prompt template mode, giving users complete control over the system prompt.
• ›Supports configuring a custom OpenAI host, enabling use with OpenAI-compatible endpoints.
• ›Adds organization and project fields for the OpenAI provider configuration.
• ›Supports OpenAI reasoning effort configuration for O1/O3 models.

Goose v1.0.7 adds Linux computer control support and verbose tool output.

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

• ›Adds Linux computer control capability, enabling automated desktop interaction on Linux systems.
• ›Introduces verbose tool output mode for more detailed visibility into tool execution.

Goose v1.0.6 adds configurable tool output, image handling, extension management, VertexAI/Claude support, and experimental Windows CLI.

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

• ›Adds goose configure flow for adjusting the amount of tool output shown in sessions.
• ›Adds support for handling images mentioned in messages.
• ›Enables removing installed extensions via the CLI.
• ›Adds server-side endpoints for config management via goose-server.
• ›Supports extending the system prompt with custom content.

Goose v1.0.5 adds AWS Bedrock provider, updated Gemini models, multi-value CLI extension options, and visible session aliases.

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

• ›Adds AWS Bedrock as a new LLM provider.
• ›Updates available Gemini models.
• ›Supports multiple values in a single CLI option when adding extensions.
• ›Makes the CLI session command alias visible in help output.
• ›Replaces the prompt for Ollama smaller models for improved compatibility.

OpenHands 0.26.0 adds Daytona sandbox runtime, CLI task automation, and UI-configurable memory condensation.

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

• ›Adds Daytona runtime support for managing sandboxes as an alternative execution environment.
• ›Enables memory condensation configuration directly from the settings page.
• ›Supports running the CLI with a task argument for fully automated, non-interactive execution.
• ›Truncates conversation history by half (instead of failing) when the LLM context limit is reached, enabling longer sessions.

OpenHands 0.25.0 adds GitLab resolver support, multi-conversation navigation, and a redesigned Settings screen.

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

• ›Adds GitLab support for the OpenHands resolver, enabling automated issue and PR resolution on GitLab repositories.
• ›New multi-conversation navigation lets users switch between different conversations without losing context.
• ›Redesigned Settings screen provides an updated UI for managing configuration.
• ›Improves filtering of sensitive data from logs, reducing credential and secret exposure in log output.

OpenHands 0.24.0 adds dockerless runtime support and success/failure indicators for file operations.

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

• ›Adds preliminary/experimental support for running OpenHands without Docker, broadening deployment flexibility.
• ›Adds success/failure indicators for file read and edit operations, giving agents clearer feedback on action outcomes.
• ›Adds comprehensive error logging to PostHog for improved observability of agent failures.

OpenHands 0.23.0 adds o3-mini support and live LLM retry visibility with rate-limit resume.

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

• ›Supports OpenAI o3-mini as a selectable LLM.
• ›Shows LLM retries in real time and enables resuming sessions from a Rate-Limited state.

SWE-agent 1.0 brings massively parallel cloud execution, configurable retries, flexible tool bundles, and a redesigned CLI.

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

• ›Adds massively parallel code execution via SWE-ReX integration, enabling fast local runs with cloud backends (Modal, AWS, or any SWE-ReX-compatible runtime).
• ›New configurable retry mechanism lets you run multiple agent configurations, models, and parameters in parallel and select the best result.
• ›Introduces flexible tool bundles for composable, user-defined tool definitions.
• ›Expands language model support to all litellm-compatible models.
• ›Adds per-run configuration overrides directly from the command line, covering any config option.

Zed v0.174.8 adds Claude Sonnet 3.7 to both Zed AI and GitHub Copilot Chat.

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

• ›Adds Claude Sonnet 3.7 as an available model in Zed AI.
• ›Adds Claude Sonnet 3.7 as an available model in GitHub Copilot Chat.

Font size commands no longer mutate settings.json by default; opt-in persistence available via keybindings.

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

[
  { "bindings": {
      "cmd-=": ["zed::IncreaseBufferFontSize", { "persist": true }],
      "cmd-+": ["zed::IncreaseBufferFontSize", { "persist": true }],
      "cmd--": ["zed::DecreaseBufferFontSize", { "persist": true }],
      "cmd-0": ["zed::ResetBufferFontSize",    { "persist": true }]
  } }
]

• ›Adds a persist argument to zed::IncreaseBufferFontSize, zed::DecreaseBufferFontSize, and zed::ResetBufferFontSize keybinding actions, allowing opt-in writing of font size changes to settings.json when set to true; without it, font size adjustments are now session-only and leave settings.json untouched.

Zed v0.173.8 introduces Edit Prediction powered by Zeta, light/dark icon themes, ToggleStagedSelectedDiffHunks, and Vim :set support.

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

{
  "icon_theme": {
    "mode": "system",
    "light": "Zed (Default)",
    "dark": "Zed (Default)"
  }
}

• ›Adds icon_theme config block with mode, light, and dark keys to support automatic light/dark icon theme switching based on system preference.
• ›Adds ToggleStagedSelectedDiffHunks action for staging and unstaging individual diff hunks.
• ›Adds editor: copy file name and editor: copy file name without extensions commands.
• ›Passes the NODE_EXTRA_CA_CERTS environment variable through to NPM when installing language servers.
• ›Introduces first version of Vim :set with support for [no]wrap, [no]number, and [no]relativenumber.

Zed v0.172.10 adds support for Google Gemini 2.0 models in the AI assistant.

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

• ›Adds support for Google's Gemini 2.0 models.

Zed v0.172.8 adds icon themes, new editor actions, show_tab_bar_buttons setting, and Copilot o3-mini support.

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

{
  "tab_bar": {
    "show_tab_bar_buttons": false
  }
}

• ›Adds show_tab_bar_buttons setting under tab_bar to enable hiding the pane tab bar buttons.
• ›Adds icon theme selector: toggle action to switch between installed icon themes; extensions can now provide icon themes.
• ›Adds editor: open selections in multibuffer command (bound to alt-enter) to open current selections in a multibuffer.
• ›Adds Copilot Chat support for the o3-mini model (removes o1-mini).
• ›Adds Vim ab/ib 'AnyBrackets' text objects, selecting the smallest of a(/a[/a{ or i(/i[/i{.

Zed v0.171.6 adds Copilot Chat support for the o3-mini model.

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

• ›Adds Copilot Chat support for OpenAI o3-mini model.

Zed v0.171.5 adds OpenAI o3-mini support and improves inline completion glob defaults.

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

• ›Improves default inline_completions.disabled_globs configuration for more accurate inline completion filtering.
• ›Adds support for the OpenAI o3-mini model in AI assistant features.

KoboldCpp v1.83.1 adds runtime model/config swapping via --admin, new vision and TTS limits, and multi-pass web search in Lite.

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

$ koboldcpp.exe --admin --admindir ./configs --adminpassword s3cret --model default.gguf

$ koboldcpp.exe --model mymodel.gguf --ttsmaxlen 1024 --visionmaxres 1024

• ›Adds --admin flag to enable runtime model, settings, and config switching (including remote model swapping) via a new Admin panel in Kobold Lite.
• ›Adds --admindir flag pointing to a directory of .kcpps launch configs, allowing hot-swap between different models, layers, and backends without restarting manually.
• ›Adds --adminpassword flag to password-protect the admin panel and remote model-swap functions.
• ›Adds --visionmaxres flag to cap the maximum resolution accepted by vision mmprojs; images exceeding the limit are automatically downscaled before processing.
• ›Adds --ttsmaxlen flag to set a token limit (range 512–4096) on TTS generation; approximately 75 tokens per second of audio.

vLLM v0.7.2 adds Qwen2.5-VL, a --model-impl=transformers backend, and a 43% DeepSeek throughput boost via KV cache alignment.

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

$ vllm serve meta-llama/Llama-3.2-1B --model-impl=transformers

$ VLLM_LOGITS_PROCESSOR_THREADS=4 vllm serve mistralai/Mistral-7B-Instruct-v0.3 --guided-decoding-backend outlines

• ›Adds --model-impl=transformers flag to run arbitrary Hugging Face text models through a transformers backend without a native vLLM model implementation.
• ›Adds VLLM_LOGITS_PROCESSOR_THREADS environment variable to parallelize structured decoding and reduce latency under high batch sizes.
• ›Adds request_success_total Prometheus counter (labelled with finish reason) for V1 engine metrics.
• ›Adds Qwen2.5-VL vision-language model support (requires source install of Hugging Face transformers).
• ›Enables MLA (Multi-head Latent Attention) for DeepSeek VL2 models, delivering the same KV cache compression as text-only DeepSeek V3/R1.

vLLM v0.7.1 delivers ~3x DeepSeek throughput via MLA kernels, FP8 block quantization, reasoning content in API, and richer V1 Prometheus metrics.

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

• ›Adds MLA decode optimization kernels for the DeepSeek model family, delivering ~3x generation throughput, ~10x token memory capacity, and horizontal context scalability via pipeline parallelism.
• ›Integrates block-quantized CUTLASS kernels (cutlass_scaled_mm with 2D group/blockwise scaling) for DeepSeekV3 FP8 inference.
• ›Adds FP8 Triton configs for block quantization and a fused MoE Triton kernel for GPTQ/AWQ quantization formats.
• ›Supports reasoning content in the API for DeepSeek R1 models.
• ›Supports overriding generation config via engine arguments.

Ollama v0.5.12 adds Perplexity R1 1776, OpenAI-compatible tool_calls responses, and X-Stainless-Timeout header support.

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

$ ollama run r1-1776

• ›Adds Perplexity R1 1776 model: a post-trained DeepSeek-R1 variant with fewer topic refusals.
• ›OpenAI-compatible API now returns tool_calls in responses when a model invokes a tool.
• ›Accepts X-Stainless-Timeout as a valid header on OpenAI API endpoints.

Ollama v0.5.9 adds DeepScaleR and OpenThinker reasoning models to the library.

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

$ ollama run deepscaler

$ ollama run openthinker

• ›Adds DeepScaleR, a 1.5B-parameter math-reasoning model fine-tuned on Deepseek-R1-Distilled-Qwen-1.5B, available via ollama pull deepscaler.
• ›Adds OpenThinker, a fully open-source family of reasoning models distilled from DeepSeek-R1, available via ollama pull openthinker.

Ollama v0.5.8 adds AVX-512 CPU acceleration and broadens GPU compatibility to non-AVX hosts

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

• ›Adds AVX-512 instruction support for additional CPU inference acceleration on compatible hardware.
• ›Enables NVIDIA and AMD GPUs on systems whose CPUs lack AVX instructions, broadening deployment targets.
• ›Adds AVX2 instruction usage when offloading to NVIDIA and AMD GPUs for improved hybrid performance.
• ›New ollama-darwin.tgz archive package replaces the previous ollama-darwin standalone binary for macOS distribution.

Phoenix 8.6.0 adds overflow span count display in the traces table UI.

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

• ›Traces table now shows a '+ n more spans' indicator when a trace contains more spans than are visible, improving at-a-glance trace size awareness.

Phoenix 8.5.0 adds a GraphQL query to retrieve per-trace span counts.

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

• ›Adds a GraphQL query to retrieve the number of spans for each trace, enabling programmatic trace-depth inspection.

Phoenix 8.4.0 adds DB usage introspection via GraphQL and persists project table column selections in the UI.

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

• ›Adds GraphQL query to retrieve the byte size of each database table, enabling admins to monitor storage consumption per table.
• ›Adds GraphQL query to retrieve the number of child spans for a given span, supporting deeper trace analysis.
• ›Adds admin-level introspection into overall database usage.
• ›Persists project table column selections in the UI so column layouts survive page reloads.

Arize Phoenix 8.1.0 adds support for standard PostgreSQL environment variables for database configuration.

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

• ›Supports configuring the PostgreSQL connection via standard environment variables PGUSER, PGPASSWORD, PGDATABASE, and PGHOST (the exact standard Postgres env var names) in addition to any existing Phoenix-specific settings.

Phoenix v8 ships a full Prompt Hub API — REST endpoints, GraphQL mutations, versioning, tagging, and OpenAI/Anthropic client helpers.

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

$ curl -X GET 'http://localhost:6006/prompts' -H 'Accept: application/json'

$ curl -X GET 'http://localhost:6006/prompts/<id>/versions' -H 'Accept: application/json'

• ›Adds GET /prompts REST endpoint to list all prompts programmatically.
• ›Adds GET /prompts/{id}/versions REST endpoint to retrieve all versions of a specific prompt.
• ›Adds POST method to the prompts REST endpoint for creating prompts via REST.
• ›Adds previous_version resolver on the PromptVersion GraphQL type to traverse version history.
• ›Adds deletePrompt and deletePromptVersionTag GraphQL mutations for lifecycle management.

Phoenix OTEL v0.8.0 enables one-line LLM instrumentation via phoenix.otel.register

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

• ›Adds phoenix.otel.register for one-line OpenTelemetry instrumentation setup in Python applications.

Phoenix 7.12.0 records URL info in playground spans for better request traceability.

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

• ›Playground spans now record URL information, enabling traceability of the exact endpoints called during playground LLM interactions.

Arize Phoenix Evals v0.20.0 adds per-model executor timeout overrides and OpenAI reasoning model support.

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

• ›Enables overriding executor timeouts on a per-model basis, allowing fine-grained control over evaluation latency limits.
• ›Supports OpenAI reasoning models that do not use the system role, enabling evals against models like o1 and o3.

Phoenix 7.11.0 adds centralized AI provider configuration in the Playground.

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

• ›Adds centralized AI provider configuration in the Playground UI, consolidating provider settings in one place.

Phoenix 7.10.0 adds experiment/dataset improvements and a base URL text field in the playground model config UI.

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

• ›Adds a base URL text field in the playground model configuration UI, enabling custom endpoint targeting for LLM providers.
• ›Improves experiment and dataset workflows with unspecified enhancements to the experiments and datasets experience.

Langfuse v3.34.0 adds GPT-4.5-preview model support and maps OTEL environment config to Langfuse environments.

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

• ›Maps OpenTelemetry environment configuration to Langfuse environment, enabling OTEL-instrumented services to automatically populate the Langfuse environment field.
• ›Adds openai gpt-4.5-preview as a supported model for cost tracking and token usage.

Langfuse v3.33.0 maps environment context to scores within the eval service.

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

• ›Eval service now maps environment to score, enabling environment-aware evaluation results.

Langfuse v3.32.0 adds onboarding screens for core features in the UI.

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

• ›Adds onboarding screens for core features to guide new users through the Langfuse UI.

Langfuse v3.31.0 adds environment property to traces, scores, and observations via API and ingestion pipeline.

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

• ›Adds environment property to traces, scores, and observations in the API, enabling environment-level filtering and segmentation of LLM telemetry.
• ›Processes environment as a first-class field in the ingestion pipeline, so environment metadata is captured and propagated at ingest time.

Langfuse v3.30.0 adds Google AI Studio support in playground and evals, plus claude-3-7-sonnet-20250219 model coverage.

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

• ›Adds Google AI Studio as a supported provider in the playground and evals features.
• ›Adds claude-3-7-sonnet-20250219 as a supported model for cost tracking and usage.

Langfuse v3.29.1 adds a redesigned prompt detail screen and system/developer message support for o3.

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

• ›Adds support for system/developer messages for o3 in LLM completion flows.
• ›Introduces a new prompt detail screen with an updated input/output and message view design.

Langfuse v3.29.0 adds MLflow OTel span parsing, expanded OTel attribute mapping, and eval support for dataset and trace history.

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

• ›Parses MLflow attributes on OpenTelemetry spans, enabling MLflow-instrumented workloads to surface in Langfuse without re-instrumentation.
• ›Maps the Langfuse data model to additional OpenTelemetry attributes, broadening OTel interoperability.
• ›Applies evaluations against the history of datasets and traces, enabling retrospective eval runs over existing data.

Langfuse v3.28.0 adds a graph view to the trace UI and TLS support for Redis connections.

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

• ›Adds TLS support for Redis connections in self-hosted deployments.
• ›Adds a graph view to the trace UI for visualizing LLM trace spans.

Langfuse v3.27.0 adds JSON content-type OTEL span ingestion, traceloop field mapping, and raises export row limit to 1M.

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

• ›OTEL ingestion endpoint now accepts application/json content-type spans in addition to the existing binary protobuf format.
• ›Maps traceloop.entity.input and traceloop.entity.output OTEL attributes to Langfuse's native input/output fields automatically.
• ›Raises the maximum row limit for exports to 1M rows, unlocking large-scale dataset exports.

Langfuse v3.26.0 enriches OpenTelemetry LLM span mapping and adds select-all to data tables.

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

• ›Adds select-all interface to tables in the UI, enabling bulk operations across all rows at once.
• ›Populates input/output and name fields on traces ingested via OpenTelemetry, improving observability of OTEL-sourced data.
• ›Maps additional properties for OpenTelemetry LLM spans, broadening the semantic coverage of OTEL ingestion.

Langfuse v3.25.0 adds Gemini 2.0 Flash, Flash-Lite, and Pro to playground and evals, plus custom GID/UID support.

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

• ›Adds playground and eval support for Gemini 2.0 Flash, Gemini 2.0 Flash-Lite, and Gemini 2.0 Pro models.
• ›Adds custom GID and UID support for self-hosted deployments.

Langfuse v3.24.0 adds local ISO date display with UTC on hover and millisecond precision on traces.

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

• ›Displays local ISO dates with UTC time on hover and millisecond precision in the traces UI.

Weave v0.51.34 adds HuggingFace inference integration, new LLM scorers, PII redaction via Presidio, and global attributes on init.

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

import weave

weave.init('my-project', global_attributes={'pipeline': 'rag-v2', 'environment': 'production'})

• ›Adds PresidioEntityRecognitionGuardrail for PII entity recognition using Microsoft Presidio, with support for custom_entities via PresidioScorer.
• ›Adds PII redaction capability for Weave traces using Microsoft Presidio.
• ›Adds PromptInjectionLLMGuardrail (refactored) for detecting prompt injection attacks.
• ›Adds option to set global attributes in weave.init, allowing trace-level metadata to be attached to all calls in a session.
• ›Adds new built-in scorers: WeaveHallucinationScorer, WeaveTrustScorer, a Coherence Scorer, and a Context Relevance Scorer.

Weave v0.51.33 adds prompt injection detection guardrails, a disk cache for server functions, and a Scorer logs viewer.

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

• ›Adds an LLM-assisted prompt injection detection guardrail to the Guardrails module.
• ›Implements a disk cache for idempotent server functions, reducing redundant computation.
• ›Allows derived columns to be used as variables in the Weave expression editor.
• ›Passes derived columns as new variables onto the stack in panel plots.
• ›Adds a Runs History Tables Scrubber for navigating run history.

Composio v0.7.2 adds Google Gemini, Agno, and smol agent plugins plus granular exception classes for external APIs.

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

• ›Adds more granular exception classes for external APIs, enabling finer-grained error handling in integrations.
• ›Adds a Google Gemini plugin, extending Composio's AI framework integrations to include Gemini.
• ›Adds an Agno plugin, bringing Agno agent framework support to Composio.
• ›Adds a smol agent plugin, enabling smol-agent workflows within Composio.
• ›Adds a deep researcher example using the AI SDK.

Composio v0.7.1-0 adds no_auth scheme support, limitedActions filtering, checkRequest overrides, and trigger methods on toolsets.

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

• ›Adds no_auth auth scheme type in Python, including proper error handling during initiate_connection for tools that require no authentication.
• ›Adds limitedActions parameter to getTools to filter the returned action set to only the specified actions.
• ›Adds support for checkRequest actions override in the OpenAI integration, enabling per-request action validation customization.
• ›Adds trigger methods directly on the toolset object, allowing trigger management without a separate client call.

Composio v0.7.0 adds connectedAccountIds support at toolset init and updates file upload/download on toolsets.

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

• ›Adds connectedAccountIds parameter to toolset initialization, enabling scoped tool execution against specific connected accounts.
• ›Updates file upload and download mechanism on toolsets, improving how files are transferred through tool actions.

LanceDB python-v0.20.0 adds async search(), multivector on remote tables, and a variable store in the embeddings registry.

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

import asyncio
import lancedb

async def main():
    db = await lancedb.connect_async("~/.lancedb")
    table = await db.open_table("my_vectors")
    results = await table.search([0.1, 0.2, 0.3]).limit(10).to_pandas()
    print(results)

asyncio.run(main())

• ›Adds search() method to the async Python API (AsyncTable), bringing parity with the sync interface for non-blocking vector search workflows.
• ›Supports multivector queries on remote tables, enabling multi-embedding search against LanceDB Cloud/remote endpoints.
• ›Adds a variable store to the embeddings registry, allowing parameterized embedding function configuration at registry level.
• ›Pushes filters down into the DataFusion table provider, improving query performance for filtered vector searches.

LanceDB v0.17.0 adds multivector remote table support, async search(), variable store in embeddings registry, and filter pushdown.

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

• ›Adds search() method to the Python async API, bringing parity with the sync interface for async workflows.
• ›Adds variable store to the embeddings registry, enabling parameterized embedding configurations (breaking change — see below).
• ›Supports multivector search on remote tables.
• ›Pushes filters down into the DataFusion table provider, improving query performance for filtered vector searches.

LanceDB v0.16.1-beta.3 adds multivector search support on remote tables.

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

• ›Supports multivector queries on remote tables, enabling multi-vector search workflows against remotely hosted LanceDB tables.
• ›Upgrades the underlying Lance library to 0.23.1-beta.4.

LanceDB python-v0.19.1-beta.3 adds multivector support on remote tables.

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

• ›Supports multivector search on remote tables, enabling multi-vector queries against LanceDB Cloud/remote table endpoints.
• ›Upgrades underlying Lance storage engine to 0.23.1-beta.4.

LanceDB v0.16.0 adds drop_index(), streaming large writes, extra headers in client options, and subschema upserts for Node

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

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

• ›Adds drop_index() method (local and remote implementations) to programmatically remove indexes from tables.
• ›Adds distance_type() parameter and metric() alias to Python sync query builders for explicit distance metric selection.
• ›Adds extra_headers parameter in client options for passing custom HTTP headers to remote connections.
• ›Adds streaming larger-than-memory writes in the Python SDK, enabling ingestion of datasets that exceed available RAM.
• ›Adds support for inserting and upserting subschemas in the Node.js SDK.

LanceDB python-v0.19.0 adds drop_index(), streaming writes, distance_type() query param, and extra headers in client options.

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

table.drop_index("my_vector_index")

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

• ›Adds drop_index() method (including remote implementation) to remove indexes from tables programmatically.
• ›Adds distance_type() parameter to Python sync query builders, with metric() as an alias, for explicit control over vector distance calculations.
• ›Adds extra_headers parameter in client options for passing custom HTTP headers to remote connections.
• ›Supports streaming larger-than-memory writes in Python, enabling ingestion of datasets that exceed available RAM.
• ›Renames drop_db / drop_database to drop_all_tables and exposes the database object directly from the connection.

Milvus 2.5.5 scales to 10K collections and 100K partitions, adds new metrics, management API, and interim index improvements.

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

proxy:
  maxTaskNum: 2048

• ›Adds proxy.maxTaskNum config key (default synced to 1024) to control the proxy task queue depth.
• ›Exports index request timeout interval via a new config entry to allow tuning without code changes.
• ›Adds configs for compaction schedule, giving operators control over compaction timing behavior.
• ›Adds a management API to check querycoord balance status, enabling operational visibility into query node distribution.
• ›Adds withEnableMatch syntactic sugar to the Go SDK for simpler match-based search construction.

Milvus 2.4.22 adds configurable compaction intervals, topks in RESTful v2 search responses, and broad load/recovery performance improvements.

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

• ›Returns topks field in RESTful v2 search responses.
• ›Adds a secondary index for QueryNode segment manager to accelerate query execution.
• ›Reads collection-level metadata concurrently to speed up failure recovery.
• ›Increases metadata list batch size to speed up recovery.
• ›Reduces locking in DataCoord to speed up load and insert operations.

Qdrant v1.13.3 adds env-var peer/bootstrap URI config, consensus compaction on by default, Retry-After rate-limit headers, and a default log format config key.

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

• ›Adds support for passing peer/bootstrap URI via environment variables, simplifying cluster setup without config-file edits.
• ›Adds Retry-After HTTP header to REST responses when the rate limiter is exhausted, letting clients back off correctly.
• ›Adds a default log format property to the Qdrant configuration file.
• ›Enables consensus compaction by default, enabling faster peer joining and cluster recovery.
• ›Excludes unversioned and partially persisted points from reads and writes, preventing stale or incomplete data from appearing in search results or updates.

Weaviate v1.28.5 adds four NVIDIA integration modules, expands RBAC with group assignment endpoints, and broadens gRPC aggregate support.

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

$ curl -X POST http://localhost:8080/v1/schema \
  -H 'Content-Type: application/json' \
  -d '{
    "class": "Document",
    "vectorizer": "text2vec-nvidia"
  }'

• ›Adds reranker-nvidia module for reranking results via NVIDIA APIs.
• ›Adds generative-nvidia module for generative (RAG) workflows via NVIDIA APIs.
• ›Adds text2vec-nvidia module for text vectorization via NVIDIA APIs.
• ›Adds multi2vec-nvidia module for multimodal vectorization via NVIDIA APIs.
• ›Adds EXPERIMENTAL_AUTHORIZATION_READONLY_GROUPS environment variable to configure read-only RBAC root groups.

Weaviate v1.27.12 adds image support in dynamic RAG syntax and parallelizes local and remote shard search.

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

• ›Adds image support in dynamic RAG syntax, enabling multimodal retrieval-augmented generation queries.
• ›Parallelizes local and remote shard search, improving query performance across distributed deployments.