The AI Toolchain — issue -371, December 31, 2024

Aider v0.69.0 adds watch-all-files AI comments, multiline input mode, Gemini Flash 2.0 Exp support, and richer copy-context.

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

$ # ... AI? Why does this function return None instead of raising an exception?

$ aider --multiline

$ /copy-context Focus on security vulnerabilities in the authentication flow

• ›Supports # ... AI? comments in any file to trigger Aider and ask inline questions about code.
• ›Watch mode now monitors all files (not just selected source types), with AI comment support via # AI, // AI, or -- AI syntax.
• ›Adds --multiline flag and /multiline-mode command to make ENTER a soft newline and META-ENTER send the message.
• ›Full support for Gemini Flash 2.0 Exp via --model flash or --model gemini/gemini-2.0-flash-exp.
• ›/copy-context now accepts optional instructions to include when copying code context to the clipboard.

Aider v0.68.0 adds copy-paste mode for LLM web UIs, CLI API key management, and bash/zsh watch-file support.

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

$ aider --copy-paste

$ aider --api-key anthropic=sk-ant-<your-key>

• ›New --copy-paste mode enables Aider to work with LLM web chat UIs (e.g., ChatGPT, Claude.ai) instead of requiring a direct API connection.
• ›New /copy-context command copies the current context to the clipboard for pasting into an LLM web chat UI.
• ›New --api-key provider=key setting lets you supply API keys for any provider directly from the command line or a YAML config file.
• ›New --set-env VAR=value setting lets you configure arbitrary environment variables for LLM providers from the command line or YAML config.
• ›Adds bash and zsh support to --watch-files, enabling auto-detection of AI coding comments in shell scripts.

Aider v0.67.0 adds in-editor AI comment instructions, Amazon Bedrock Nova support, and smarter /diff and /run workflows.

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

$ aider --watch-files

• ›New --watch-files mode lets aider watch source files for inline AI instructions — trigger execution by ending a comment with AI!.
• ›Supports new Amazon Bedrock Nova models.
• ›The /diff command now invokes git diff, honouring your configured diff tool.
• ›Adds Ctrl-Z support for process suspension.

Aider v0.66.0 adds PDF support for Sonnet/Gemini, voice device selection, API timeout control, and improved /drop matching.

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

$ aider --voice-input-device 2

$ aider --timeout 120

• ›Adds PDF support for Sonnet and Gemini models, enabling document context in chats.
• ›New --voice-input-device flag lets you select the audio input device for voice recording.
• ›New --timeout option configures API call timeouts.
• ›Sets working directory to repo root when running shell commands.
• ›Adds Ctrl-Up/Down keyboard shortcuts for per-message history navigation.

Cline v2.2.0 adds Model Context Protocol (MCP) support, letting you plug in or auto-generate custom tools on demand.

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

$ add a tool that manages AWS EC2s

• ›Supports Model Context Protocol (MCP), enabling plug-and-play integration of external tool servers (e.g. web search, GitHub) via a new server icon in the menu bar.
• ›Enables Cline to autonomously create and install new MCP server tools from a natural-language prompt (e.g. 'add a tool that fetches Jira tickets').
• ›Saves auto-generated MCP servers to ~/Documents/Cline/MCP for easy reuse and sharing across workflows.

OpenHands 0.16.1 adds file-by-file download with progress and backend config saving infrastructure.

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

• ›Adds file-by-file download with progress tracking for workspace files.
• ›Introduces infrastructure for saving configuration on the backend rather than the frontend.

OpenHands 0.16.0 updates GitHub Authentication flow.

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

• ›Updates GitHub Authentication integration.

OpenHands 0.15.3 raises default max_iterations to 500 and resets turn budget per user interaction

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

• ›Adds color coding to the 'Ran a Command' UI indicator based on command return value, making pass/fail status immediately visible.
• ›Increases default max_iterations to 500, enabling agents to tackle longer, more complex tasks before hitting the iteration limit.
• ›Measures the turn limit from the last user interaction rather than session start, giving agents a full budget after each user message.
• ›Persists jwt_secret in the config file so the secret survives service restarts without manual reconfiguration.

OpenHands 0.15.2 adds workspace-level custom MicroAgents, resolver code-review requests, and browser observations in chat.

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

• ›Adds support for Custom MicroAgents placed directly in the connected workspace, enabling project-specific agent behavior without global configuration.
• ›Enables the resolver to automatically request a code review from the person who initiated it after completing a PR.
• ›Surfaces browser observations (what the agent sees while web browsing) directly in the chat interface for real-time visibility.

OpenHands 0.15.1 adds command-run notifications and multiline message support in headless mode.

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

• ›Shows a status message in the UI each time the agent executes a command, giving real-time visibility into agent actions.
• ›Supports multiline user messages, and provides a default user message when running in headless mode.

OpenHands 0.15.0 adds SocketIO comms, BrowseURLAction in CodeAct, custom resolver sandboxes, and multi-tab session sharing.

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

• ›Switches underlying client-server communication to SocketIO for more robust real-time messaging.
• ›Adds BrowseURLAction to the CodeAct agent, enabling it to navigate URLs as part of agentic workflows.
• ›Adds an alignment checker for the browsing agent to verify page-interaction accuracy.
• ›Supports custom sandbox images for the GitHub issue resolver.
• ›Adds a microagent to automatically handle npm timeout issues during code execution.

Zed v0.165.4 adds terminal panel splitting, zed --uninstall, new Vim motions/text objects, and a show_user_picture setting.

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

$ zed --uninstall

{
  "show_user_picture": false
}

{
  "vim": {
    "highlight_on_yank": true,
    "highlight_on_copy": false
  }
}

• ›Adds zed --uninstall CLI flag to cleanly uninstall Zed.
• ›Adds autoscroll_on_clicks setting to configure whether the editor scrolls when clicking near the edges of the visible text area.
• ›Adds show_user_picture setting (default: true) to hide the user profile picture in the titlebar.
• ›Adds editor::FoldFunctionBodies action to fold all function bodies in textobject-supported languages.
• ›Adds Vim settings highlight_on_yank and highlight_on_copy to control highlight behavior on yank/copy.

Zed v0.164.2 adds file_scan_inclusions, task output controls, image rendering in Markdown preview, and expanded Vim motions.

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

"file_scan_inclusions": ["vendor/**", "generated/**", ".env*"]

"show_summary": false,
"show_command": false

• ›Adds file_scan_inclusions setting to force Zed to index files matching provided globs even when they are gitignored.
• ›Adds show_summary and show_command task settings to suppress the summary and command line from task output.
• ›Adds image rendering to the Markdown preview.
• ›Adds support for extension languages on the remote server (SSH Remoting).
• ›Adds support for ctrl-k / ctrl-y alternate cut/yank buffer on macOS.

AutoGPT Platform v0.3.4 adds webhook-triggered blocks, AI video generation, HubSpot integration, and searchable block descriptions.

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

• ›Adds webhook-triggered blocks, enabling agent workflows to be initiated by incoming webhooks.
• ›Introduces feature flagging to the platform, allowing controlled rollout of capabilities.
• ›Adds an AI video generation block powered by Fal txt2vid for generating video from text inside agent flows.
• ›Enables search over Block descriptions in the Block list palette, making it faster to discover the right block.
• ›Adds new HubSpot integration blocks for connecting agent workflows to HubSpot.

CrewAI 0.85.0 adds agent-level knowledge, removes LangChain dependency, and improves typed task outputs.

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

• ›Adds knowledge support at the individual agent level, enabling per-agent knowledge bases alongside crew-level knowledge.
• ›Removes LangChain as a dependency, reducing the library's footprint and eliminating LangChain version conflicts.
• ›Improves typed task outputs for stronger, more predictable structured results from tasks.
• ›Adds Tool Repository authentication via crewai login, enabling access to hosted tools.

DSPy 2.6.0rc4 adds streaming support for language model calls.

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

• ›Adds streaming support for language model outputs.

DSPy 2.6.0rc3 adds LiteLLM RetryPolicy support and thread-safe Settings semantics.

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

• ›Supports automatic retries for LM calls via LiteLLM RetryPolicy integration.
• ›Refines thread-safety semantics for Settings to make concurrent DSPy usage more reliable.

DSPy 2.5.43 adds logprob support in Predictor and a new docs_uri_column_name field for DatabricksRM.

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

retriever = DatabricksRM(
    databricks_index_name='my_index',
    docs_uri_column_name='source_url',
    text_column_name='content',
    k=5
)

• ›Adds docs_uri_column_name parameter to DatabricksRM to specify which column holds document URIs when retrieving results.
• ›Enables returning log probabilities from Predictor, exposing token-level confidence scores for model outputs.
• ›Improves DSPy module saving fidelity.

DSPy 2.5.42 adds tool callbacks, in-memory LM caching, structured output support, and broader type coverage.

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

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

langchain-mistralai 0.2.4 adds automatic retry logic to MistralAIEmbeddings on rate-limit errors.

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

• ›Adds a retrying mechanism to MistralAIEmbeddings that automatically retries requests when a rate-limit error is encountered.

langchain-ollama 0.2.2 adds structured output support to Ollama-backed LLM calls.

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

• ›Adds structured output support for Ollama models, enabling schema-constrained response generation.

LangChain core 0.3.26 exports InjectedToolCallId and adds kwargs support to VectorStore

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

from langchain_core.tools import InjectedToolCallId
from langchain_core.tools import tool
from typing import Annotated

@tool
def my_tool(query: str, tool_call_id: Annotated[str, InjectedToolCallId()]) -> str:
    return f'Handling call {tool_call_id} for query: {query}'

• ›Exports InjectedToolCallId from langchain_core, making it part of the public API and importable for annotating tool call ID injection in tool functions.
• ›Adds **kwargs support to VectorStore, allowing subclasses and callers to pass arbitrary keyword arguments through vector store methods.

LangChain Community 0.3.12 adds OpenSearch hybrid search, FAISS advanced query operators, Tablestore vector store, Azure Cosmos DB DiskANN, and more integrations.

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

loader = O365BaseLoader(..., modified_since='2024-12-01T00:00:00Z')
docs = loader.load()

from langchain_community.vectorstores import OpenSearchVectorSearch

vs = OpenSearchVectorSearch(
    index_name='my-index',
    embedding_function=embeddings,
    opensearch_url='https://localhost:9200',
    bulk_size=500,
)

• ›Adds modified_since argument to O365BaseLoader to filter loaded documents by modification date.
• ›Adds bulk_size as a settable parameter for OpenSearchVectorSearch to control indexing batch size.
• ›Adds FAISS filter function enhancement with advanced query operators for more expressive vector search filtering.
• ›Adds OpenSearch hybrid search implementation combining dense and sparse retrieval.
• ›Adds TablestoreVectorStore integration for Alibaba Cloud Tablestore as a vector store backend.

LangChain Core 0.3.25 adds a new scoped_full clean-up strategy to the indexing API.

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

• ›Adds scoped_full as a new clean-up strategy option in the indexing API, giving practitioners a scoped variant of full deletion during index runs.

LangChain Community 0.3.11 adds model2vec embeddings, Confluence label filtering, Memgraph updates, and KuzuGraph dangerous-request gating.

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

from langchain_community.document_loaders import ConfluenceLoader

loader = ConfluenceLoader(
    url="https://your-org.atlassian.net/wiki",
    username="[email protected]",
    api_key="<api_key>",
    space_key="ENG",
    include_labels=["approved", "public"]
)
docs = loader.load()

from langchain_community.graphs import KuzuGraph
from langchain_experimental.graph_transformers import LLMGraphTransformer
from langchain_openai import ChatOpenAI

graph = KuzuGraph(database=db, allow_dangerous_requests=True)
llm = ChatOpenAI(model="gpt-4o")
transformer = LLMGraphTransformer(llm=llm)
graph_docs = transformer.convert_to_graph_documents(docs)
graph.add_graph_documents(graph_docs)

• ›Adds include_labels option to ConfluenceLoader to filter loaded content by Confluence labels.
• ›Adds support for model2vec embeddings via a new integration in the community package.
• ›Adds allow_dangerous_requests parameter to KuzuGraph and enables adding graph documents via LLMGraphTransformer.
• ›Adds Pebblo support for the new Pinecone class PineconeVectorStore.
• ›Retains Azure Document Intelligence API metadata in the Document parser output.

langchain-community 0.3.10 adds Needle retriever/loader, SAP HANA HNSW index support, PubMed API key auth, and BM25 document ID preservation.

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

• ›Adds Needle retriever and document loader integration, enabling retrieval workflows backed by the Needle service.
• ›Adds HNSW index creation support for SAP HANA Vector Store, unlocking approximate nearest-neighbor search at scale.
• ›Adds apikey parameter support to PubMedAPIWrapper, allowing authenticated PubMed API access.
• ›Adds _select_relevance_score_fn implementation for Tencent VectorDB, enabling correct similarity score normalization.
• ›Preserves original document IDs in BM25Retriever, preventing ID loss on retrieval.

LangChain tests 0.3.5 adds standard retriever tests and final AIMessage support in tool_example_to_messages

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

• ›Adds standard tests for retrievers via new retriever standard test suite (tests: init retriever standard tests).
• ›Supports final AIMessage responses in tool_example_to_messages in langchain-core.
• ›Adds standard tests to the CLI, including validation that they run and skipping of vector store tests.

langchain-ollama 0.2.1 adds token-level streaming with bound tools and passes extra kwargs through to Ollama requests.

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

• ›Enables token-level streaming when using bind_tools with ChatOllama, allowing real-time output during tool-augmented calls.
• ›Passes extra kwargs through in Ollama requests, giving callers access to additional Ollama API parameters.
• ›Adds support for Ollama 0.4.
• ›Supports tool calling with nested schemas in ChatOllama.

langchain-community 0.3.9 adds truncation params for OpenAI assistant runs, Perplexity citations in AIMessage, and NumPy 2 support.

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

• ›Adds truncation parameters when an OpenAI assistant's run is created, giving control over context window usage.
• ›Adds citations in AIMessage for ChatPerplexity, surfacing source attribution directly in chat responses.
• ›Supports NumPy 2 in community integrations.
• ›Updates Marqo index settings to use the 2.x API version while retaining backward compatibility with 1.5.x.

LangGraph SDK 0.1.48 adds StudioUser class for fine-grained authorization control over LangGraph Studio UI access.

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

from langgraph_sdk.auth.types import StudioUser

def my_auth_handler(user, action, resource):
    if isinstance(user, StudioUser):
        raise PermissionError("Studio users cannot access this resource")
    return True

{
  "disable_studio_auth": true
}

• ›Adds StudioUser class in langgraph_sdk/auth/types.py representing authenticated users from the LangGraph Studio UI, exposing properties for username, display name, identity, permissions, and auth status.
• ›Enables custom authorization handlers to branch on Studio vs. non-Studio users via isinstance(user, StudioUser) checks.
• ›Supports disabling Studio authentication entirely via disable_studio_auth: true in langgraph.json.

LangGraph 0.2.60 makes Command.update accept any type and relaxes tool node validation for multi-message responses.

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

from langgraph.types import Command

# Now valid: update can be any type, including None or a plain string
cmd = Command(goto="next_node", update="my_custom_payload")

from langchain_core.messages import ToolMessage
from langgraph.types import Command

# Both messages returned; validation passes because one has the matching tool_call_id
cmd = Command(
    update={
        "messages": [
            ToolMessage(content="debug info", tool_call_id="other-id"),
            ToolMessage(content="actual result", tool_call_id="call-123"),
        ]
    }
)

• ›Extends Command.update to accept any type of value (not just dicts or sequences of tuples), including None, enabling more diverse node-to-node command patterns.
• ›Relaxes prebuilt tool_node validation to allow multiple tool messages in a command update, requiring only that at least one message matches the tool call ID.

LangGraph SDK 0.1.47 simplifies auth handlers and renames scopes to permissions in the Auth module.

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

from langgraph_sdk.auth import Auth

auth = Auth()

@auth.authenticate
async def authenticate(authorization: str) -> dict:
    user_id = verify_token(authorization)  # your token logic
    return {"identity": user_id, "permissions": ["runs:create", "threads:read"]}

• ›Simplifies authentication handler return type: handlers now return a user representation directly (string, dict, or object) instead of a (scopes, user) tuple.
• ›Adds permissions field to MinimalUserDict and permissions property to the BaseUser interface in Auth.types.
• ›Updates Authenticator type signature to reflect the new single-object return format.

LangGraph CLI now validates dependencies in configuration, with graceful fallback when the field is absent.

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

• ›Adds dependencies field validation to validate_config, ensuring dependency declarations are checked and included during config processing.

LangGraph SDK 0.1.46 adds HTTPException to auth handlers for precise HTTP error control

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

from langgraph_sdk import Auth

auth = Auth()

@auth.authenticate
async def my_auth_handler(token: str):
    if not is_valid(token):
        raise auth.exceptions.HTTPException(
            status_code=403,
            detail="You do not have permission to access this resource."
        )
    return {"user": decode(token)}

• ›Adds HTTPException class to Auth.exceptions, letting auth handlers return custom HTTP status codes, error messages, and headers instead of generic failures.
• ›Exposes exceptions module on the Auth class for clean, importable access to auth-related exception types.

LangGraph CLI 0.1.63 adds OpenAPI security scheme configuration to AuthConfig for customizing API auth settings.

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

• ›Adds SecurityConfig TypedDict class for defining OpenAPI security schemes and requirements in authentication config.
• ›Extends AuthConfig with a new openapi field of type SecurityConfig, enabling customization of API security settings such as OAuth2 scopes and token endpoints.

LangGraph CLI 0.1.62 adds auth configuration support for LangGraph Studio with a new AuthConfig type.

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

# langgraph.json
{
  "auth": {
    "path": "./my_auth.py:handler",
    "disable_studio_auth": true
  }
}

• ›New AuthConfig TypedDict with path and disable_studio_auth fields enables custom authentication configuration for LangGraph Studio.
• ›New auth field on the main Config TypedDict wires auth settings into config validation and Docker environment generation.
• ›The dev command now accepts auth configuration, allowing Studio auth to be controlled at dev-server launch time.

LangGraph SDK 0.1.45 adds an Auth class with decorator-based authentication and fine-grained per-resource authorization.

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

from langgraph_sdk import Auth

auth = Auth()

@auth.authenticate
async def verify_token(token: str):
    # validate token and return user scopes
    user = await my_token_validator(token)
    return {"id": user.id, "scopes": user.scopes}

@auth.on
async def global_handler(ctx, value):
    # allow only requests where the resource owner matches the caller
    if ctx.user.id != value.get("owner"):
        raise Auth.exceptions.HTTPException(status_code=403)

from langgraph_sdk import Auth

auth = Auth()

@auth.on.threads.read
async def restrict_thread_reads(ctx, value):
    # inject a filter so the query only returns threads owned by the caller
    return {"owner": ctx.user.id}

• ›Adds Auth class providing a unified authentication and authorization system for LangGraph applications.
• ›Supports decorator-based auth handlers to verify credentials and return user scopes.
• ›Enables fine-grained access control per resource (threads, assistants, crons) and per action (create, read, update, delete, search).
• ›Implements a hierarchical handler system supporting global fallback handlers alongside specific per-action handlers.
• ›Introduces a new types module with typed dictionaries (e.g., ThreadsCreate, AssistantsRead), protocol definitions for user objects and auth handlers, and strongly-typed context objects.

LangGraph 0.2.59 enables config-aware tool execution by passing configuration to prebuilt tool node invocations.

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

• ›Enables prebuilt tool node to pass the configuration object to tools during both synchronous (invoke) and asynchronous (ainvoke) execution, allowing tools to access runtime configuration parameters.

LangGraph 0.2.58 adds string node names in Command.goto and richer config metadata with defaults and descriptions.

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

from langgraph.types import Command

# Previously required Send; now a plain string works
def my_node(state):
    return Command(goto="approval_node")

from langgraph.utils.fields import get_enhanced_type_hints

# Get type hints plus defaults and descriptions for a config schema
hints = get_enhanced_type_hints(MyConfigSchema)
print(hints)

• ›Supports string values in Command.goto, enabling direct node-name references instead of requiring Send objects for state transitions.
• ›Adds get_enhanced_type_hints utility to extract type hints along with default values and descriptions, covering Pydantic models, TypedDict, and dataclasses.
• ›Enriches Pregel.config_specs output with default values and descriptions for configuration fields via get_enhanced_type_hints.

LangGraph 0.2.57 adds a functional API with @task/@entrypoint decorators and lets tools return Command objects.

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

from langgraph.func import task, entrypoint

@task
def call_model_a(prompt: str) -> str:
    return llm_a.invoke(prompt)

@task
def call_model_b(prompt: str) -> str:
    return llm_b.invoke(prompt)

@entrypoint()
def compare_models(prompt: str) -> dict:
    future_a = call_model_a(prompt)
    future_b = call_model_b(prompt)
    return {"a": future_a.result(), "b": future_b.result()}

result = compare_models.invoke("Explain quantum entanglement")

from langchain_core.tools import tool
from langgraph.types import Command

@tool
def escalate_to_human(reason: str) -> Command:
    """Escalate the conversation to a human agent."""
    return Command(goto="human_node", update={"escalation_reason": reason})

# Register with ToolNode as usual — Command routing is handled automatically
from langgraph.prebuilt import ToolNode
tool_node = ToolNode([escalate_to_human])

• ›Adds @task decorator (langgraph.func.task) for creating parallel async tasks that return futures, with optional retry policies.
• ›Adds @entrypoint decorator (langgraph.func.entrypoint) to wrap regular or generator functions into Pregel graphs as callable entry points.
• ›Enables Command objects to be returned directly from LangChain tools via ToolOutputMixin compatibility and ToolNode support.
• ›Adds StateGraph support for lists of Command objects and tuple-based state updates in node outputs.
• ›Adds _repr_mimebundle_ to Graph for inline Mermaid diagram visualization in Jupyter notebooks.

LangGraph SDK 0.1.43 adds query-param streaming and expands Command routing flexibility

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

async for chunk in client.stream(
    assistant_id,
    thread_id,
    input=input_data,
    params={"my_filter": "value", "limit": 10},
):
    print(chunk)

from langgraph.types import Command, Send

cmd = Command(goto=[Send("node_a", {"x": 1}), "node_b"])

• ›Adds optional params argument to HttpClient.stream() (async and sync) so query parameters can be passed with streaming requests.
• ›Expands Command TypedDict's goto field to accept Send, str, or a sequence of either, enabling richer graph routing in command structures.

LangGraph 0.2.55 overhauls interrupt/resume with scratchpad tracking and consolidates Send into the goto field

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

from langgraph.types import Command, Send

# Route to a named node and dynamically send a message to another node
cmd = Command(goto=["review_node", Send("process_node", {"input": data})])

from langgraph.types import interrupt

def my_node(state):
    first_answer = interrupt("Please provide your name")
    second_answer = interrupt("Please provide your role")
    return {"name": first_answer, "role": second_answer}

• ›Adds CONFIG_KEY_WRITES constant exposing a read-only list of existing task writes to task configuration
• ›Adds CONFIG_KEY_SCRATCHPAD constant providing temporary storage scoped to the current task
• ›Rewrites the interrupt function with interrupt-count tracking to correctly handle multiple interrupts within the same node
• ›Enables goto field on Command to accept both string node names and Send objects, unifying send/goto into one API
• ›Deduplicates writes to special channels in PregelLoop.put_writes (last write wins)

LangGraph 0.2.54 adds parent-graph command routing, empty-tool ReAct agents, and Command input support for RemoteGraph.

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

from langgraph.types import Command

def subgraph_node(state):
    # Direct this command at the parent graph instead of the current one
    return Command(goto="some_parent_node", update={"status": "delegated"}, graph=Command.PARENT)

from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

agent = create_react_agent(ChatOpenAI(model="gpt-4o"), tools=[])
result = agent.invoke({"messages": [{"role": "user", "content": "Summarise the history of cryptography."}]})

from langgraph.pregel.remote import RemoteGraph
from langgraph.types import Command

remote = RemoteGraph("my-deployed-graph", url="https://my-langgraph-server")
for chunk in remote.stream(Command(goto="review_node", update={"approved": True}), config={"thread_id": "abc123"}):
    print(chunk)

• ›Adds Command.PARENT constant ("__parent__") and a graph field on Command so nodes in a subgraph can route commands up to the parent graph.
• ›Adds GraphBubbleUp base exception class and new ParentCommand exception to propagate parent-directed commands cleanly through the graph hierarchy.
• ›Enables create_react_agent to accept an empty tools list, producing a simple LLM-only graph without tool-calling plumbing.
• ›Enables RemoteGraph.stream and RemoteGraph.invoke to accept Command objects directly as input, with pass-through of additional client kwargs.
• ›Graph validation now only requires at least one edge from START; unreachable nodes no longer cause a validation error.

LangGraph SDK 0.1.42 adds run status filtering, cancel-on-disconnect streaming, and command support in assistant APIs.

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

runs = await client.runs.list(thread_id="<thread_id>", status="pending")

async for chunk in client.runs.join_stream(thread_id="<thread_id>", run_id="<run_id>", cancel_on_disconnect=True):
    print(chunk)

async for chunk in client.assistants.stream(assistant_id="<assistant_id>", command=<command>):
    print(chunk)

• ›Adds status parameter to RunsAPI.list() to filter runs by execution status.
• ›Adds cancel_on_disconnect parameter to RunsAPI.join_stream() to automatically cancel a run when the client disconnects from the stream.
• ›Adds command parameter to AssistantAPI.stream(), .create(), and .wait() for finer control over assistant execution.
• ›Adds Interrupt type definition and exposes interrupt information on the Thread schema for improved interrupt handling.

langgraph-checkpoint-postgres 2.0.7 adds configurable vector indices (HNSW, IVFFlat, flat) and improved vector search ordering.

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

from langgraph.store.postgres.base import ANNIndexConfig, IVFFlatConfig

index_config = ANNIndexConfig(
    kind="ivfflat",
    ann_index_config=IVFFlatConfig(nlist=256),
)

• ›Adds ANNIndexConfig with a kind field to select vector index type: 'hnsw', 'ivfflat', or 'flat'.
• ›Adds HNSWConfig class for tuning HNSW indices via m (max connections per layer) and ef_construction (dynamic candidate list size).
• ›Adds IVFFlatConfig class for tuning IVFFlat indices via nlist (number of inverted lists/clusters).
• ›Adds automatic vector index creation in BasePostgresStore based on the supplied index configuration.
• ›Adds condition field to Migration to support conditional migration execution based on store configuration.

Letta 0.6.6 adds ConditionalToolRules, two new error types, non-pro model support, and SDK renames for tools and inner monologue.

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

• ›Adds ConditionalToolRules to the SDK for expressing conditional logic around tool execution order and constraints.
• ›Adds RateLimitExceededError error class to surface rate-limit failures explicitly in application code.
• ›Adds ContextWindowExceededError error class to surface context-window overflow failures explicitly in application code.
• ›Renames function to tool throughout the SDK, aligning SDK terminology with the tool abstraction.
• ›Renames internal_monologue field in the SDK (internal monologue surface renamed).

Letta 0.6.5 adds tool call stdout/stderr logs in FunctionResponse and simplifies agent creation with <provider>/<model> shorthand.

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

$ curl --request POST \
  --url http://localhost:8283/v1/agents/ \
  --header 'Content-Type: application/json' \
  --data '{
    "memory_blocks": [
      {"value": "Name: Sarah", "limit": 5000, "label": "human"},
      {"value": "I am a helpful assistant", "label": "persona"}
    ],
    "llm": "anthropic/claude-3-5-sonnet-20241022",
    "embedding": "openai/text-embedding-ada-002",
    "context_window_limit": 15000
  }'

• ›Simplifies agent creation via POST /v1/agents/ by accepting llm and embedding fields in <provider>/<model> format (e.g. anthropic/claude-3-5-sonnet-20241022, openai/text-embedding-ada-002) instead of full configuration objects.
• ›Adds context_window_limit field and per-block limit field to POST /v1/agents/ request body, allowing callers to cap the context window size and set character limits on individual memory blocks (e.g. human/persona).
• ›Exposes stdout and stderr logs from tool execution in the FunctionResponse object, viewable in the ADE alongside the tool response.
• ›Adds an init tool rule for the Anthropic endpoint.
• ›Publishes multiplatform Docker images.

Letta 0.6.3 adds Python 3.13 support, local HTTPS mode, file support, and a simplified agent-creation REST API.

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

$ curl --request POST \
  --url http://localhost:8283/v1/agents/ \
  --header 'Content-Type: application/json' \
  --data '{
  "memory_blocks": [
    {"value": "The human name is Bob the Builder", "label": "human"},
    {"label": "persona", "value": "My name is Sam, the all-knowing sentient AI."}
  ],
  "llm_config": {
    "model": "gpt-4o-mini",
    "model_endpoint_type": "openai",
    "model_endpoint": "https://api.openai.com/v1",
    "context_window": 16000
  },
  "embedding_config": {
    "embedding_endpoint_type": "openai",
    "embedding_endpoint": "https://api.openai.com/v1",
    "embedding_model": "text-embedding-3-small",
    "embedding_dim": 8191
  }
}'

• ›Simplifies the POST /v1/agents/ REST API for agent creation — tools and agent type now have defaults, reducing the required payload to memory_blocks, llm_config, and embedding_config.
• ›Adds local HTTPS mode support to the server.
• ›Adds file support via the new files feature.
• ›Adds logs to the response for tool runs.
• ›Supports Python 3.13, with upgraded dependencies to match.

Letta 0.6.2 adds an async messages API route, system message support for OSS and Anthropic models, and a streamlined Docker single-command setup.

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

$ docker run \
  -v ~/.letta/.persist/pgdata:/var/lib/postgresql/data \
  -p 8283:8283 \
  -e OPENAI_API_KEY="your_api_key" \
  letta/letta

• ›Adds async messages API endpoint POST /agent/{agent_id}/messages/async to support long-running agent execution without blocking.
• ›Adds system message support for OSS models (via ChatML wrapper) and Anthropic models in the send_message route.
• ›Updates Dockerfile so the Letta service can be run with a single docker run command, mounting a data volume at /var/lib/postgresql/data and accepting credentials via OPENAI_API_KEY env var or --env-file .env.
• ›Introduces an offline memory agent capability.

Letta 0.6.1 adds external codebase sandboxes for tool execution and improved venv error surfacing.

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

• ›Supports external codebases as a tool execution sandbox, enabling tools to run inside third-party code environments.
• ›Parses and surfaces errors from venv local sandbox execution so failures are visible rather than silent.
• ›Returns HTTP 404 when a requested source does not exist, making missing-resource errors explicit.

Letta 0.6.0 adds E2B tool sandboxing, ADE server password protection, Composio sandbox support, and new memory-block and tool-test APIs.

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

$ export E2B_API_KEY=your_e2b_key
export E2B_SANDBOX_TEMPLATE_ID=your_template_id
letta server

$ export LETTA_SERVER_PASSWORD=password
letta server --ade --secure --port=8283

• ›Enables E2B tool sandboxing by setting E2B_API_KEY and E2B_SANDBOX_TEMPLATE_ID environment variables, isolating tool execution in a remote sandbox.
• ›Adds --secure flag and LETTA_SERVER_PASSWORD environment variable to letta server so a password-protected local server can still connect to the ADE.
• ›Adds endpoints to add default E2B and local sandbox configurations (via the sandbox config API).
• ›Adds a POST /v1/tools/run route for testing tool execution by tool_id without running a full agent loop.
• ›Adds endpoints to list Composio apps and actions, and adds Composio tools compatibility inside sandboxes.

PydanticAI v0.0.15 adds capture_run_messages for message capture and optimizes Mistral model support.

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

• ›Adds capture_run_messages to replace last_run_messages for capturing run messages.
• ›Adds a default to ResultData so agents no longer require an explicit result-type argument.
• ›Optimizes Mistral model integration for improved performance.
• ›Tool calls are now prioritized over eager text responses when a model returns both.

PydanticAI v0.0.14 adds usage limits, renames Cost to Usage, and supports the openai:o1 model.

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

• ›Renames Cost to Usage across the library — callers must update any references to the old name.
• ›Adds support for usage limits via the new Usage tracking infrastructure.
• ›Adds openai:o1 model support.

PydanticAI v0.0.13 adds Mistral and Anthropic support, new ModelSettings, Gemini 2.0 Flash, and a reworked message format.

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

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

model = OpenAIModel('llama-3', base_url='http://localhost:11434/v1')
agent = Agent(model)
result = agent.run_sync('Summarize the threat report.')
print(result.data)

from pydantic_ai import Agent
from pydantic_ai.models.mistral import MistralModel

agent = Agent(MistralModel('mistral-large-latest'))
result = agent.run_sync('List the top 5 OWASP API risks.')
print(result.data)

• ›Adds base_url kwarg to OpenAIModel to point the client at any OpenAI-compatible endpoint (e.g. local or self-hosted inference servers).
• ›Adds messages field to RunContext so tool functions can inspect the full conversation history mid-run.
• ›Adds ToolReturnPart message part to pydantic_ai.messages, emitted for every tool call result and included in the message stream.
• ›Adds basic ModelSettings class for passing model-level configuration (temperature, etc.) to agent runs.
• ›Adds Mistral model support as a new first-class provider.

PydanticAI v0.0.12 adds Ollama support, dynamic tools, and tool-result generation for structured outputs.

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

• ›Adds Ollama as a supported model provider, enabling local LLM inference within PydanticAI agents.
• ›Introduces dynamic tools, allowing tool definitions to be resolved or modified at runtime rather than statically at agent construction.
• ›Enables tool-result generation when using structured result types, so structured-output workflows now produce proper tool result messages alongside the response.

PydanticAI v0.0.10 adds Agent.name for identifying agents in traces and logs.

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

from pydantic_ai import Agent

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

• ›Adds Agent.name attribute to label agent instances, enabling identification in observability output.

PydanticAI v0.0.9 lets you register tools at Agent construction time and return any type from tool functions.

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

• ›Adds tools parameter to Agent(tools_=[...]) constructor, allowing tools to be registered at instantiation rather than only via decorators.
• ›Allows tool functions to return Any type, removing the previous restriction that tool return values had to be a specific type.

Semantic Kernel .NET 1.32.0 adds Structured Outputs in prompts, declarative agents, MistralAI image content, and a Gemini MIME-type parameter.

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

• ›Adds responseMimeType parameter to GeminiPromptExecutionSettings for explicit control over output MIME type.
• ›Adds Structured Outputs support in prompts, enabling schema-constrained LLM responses directly from prompt templates.
• ›Adds declarative agents support, allowing agents to be defined and loaded declaratively.
• ›Adds image content support for MistralAI function calling.
• ›Adds OpenAPI operations filtering, with new samples demonstrating how to selectively expose API operations.

Semantic Kernel Python 1.17.0 graduates filters and adds streaming usage-data yield for chat completions.

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

• ›Graduates filters out of experimental status, adding an exception when a duplicate filter is added during registration.
• ›Yields StreamingChatMessageContent directly when usage data is available during streaming chat completion responses.

browser-use 0.1.16 enables parallel multi-agent browsing with multiple contexts per browser instance and trace/replay saving

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

• ›Supports spinning up multiple browser contexts per browser instance, enabling parallel execution of as many agents as needed simultaneously.
• ›Adds the ability to save traces and replays of browser agent sessions.
• ›Improved DOM processing for more reliable page interaction.

camel-ai v0.2.12 adds Brave Search, SGLang, e2b, Stripe, reward models, structured outputs, and HuggingFace dataset upload.

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

• ›Adds structured output support for ChatAgent using the OpenAI beta client, enabling typed response schemas from chat interactions.
• ›Adds structured output support for Ollama models, enabling schema-constrained responses from locally hosted Ollama instances.
• ›Integrates the Brave Web Search API into the search toolkit, giving agents a new web-search backend.
• ›Integrates SGLang as a new inference backend in CAMEL.
• ›Integrates e2b as a new code execution/sandbox backend.

camel-ai v0.2.11 adds ModelManager scheduling, NVIDIA platform support, Meshy 3D integration, and structured output improvements.

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

from camel.data_collector import AlpacaItem

item = AlpacaItem(instruction='Explain XSS', input='', output='Cross-site scripting is...')
print(item.model_dump())

• ›Adds ModelManager class to schedule and load-balance calls across multiple model backends.
• ›Adds NVIDIA model platform support, expanding available backends alongside existing OpenAI/Azure/Mistral integrations.
• ›Adds logprobs handling in choice response objects, enabling access to token-level log probabilities from model completions.
• ›Adds AlpacaItem pydantic class for easy conversion, validation, and structured Alpaca-format output generation.
• ›Supports OpenAI structured output as a typed object, enabling schema-validated responses from OpenAI models.

HolmesGPT 0.7.1 adds WatsonX support, kubectl events, grep log search, and memory-request inspection tools.

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

• ›Adds kubectl_logs_grep tool, enabling Holmes to search pod logs using grep (upgraded to grep -E extended regex) to surface relevant log lines faster.
• ›Adds a tool to fetch top memory requests across the cluster, giving the LLM visibility into resource consumption.
• ›Adds kubectl events capability so Holmes can retrieve and reason over Kubernetes events during investigations.
• ›Enables the LLM to fetch logs from all containers or a specific container within a pod, expanding container-level log coverage.
• ›Adds IBM WatsonX as a supported LLM backend, broadening model provider options.

Jan v0.5.11 adds a universal macOS build supporting both Apple Silicon and Intel in a single binary.

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

• ›Adds a universal macOS binary that runs natively on both Apple Silicon and Intel Macs without Rosetta translation.

Jan v0.5.10 adds stop word model settings, more Groq models, Anthropic model updates, and an increased Claude 3.5 max-token limit.

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

• ›Adds stop word model setting, letting users define stop sequences directly in model configuration.
• ›Increases the max-token limit for Claude 3.5 models.
• ›Adds more Groq models to the model selection.
• ›Adds updated Anthropic model options including newer Claude variants.
• ›Updates Jan's client request handling to adapt to API changes from Cortex.

SGLang v0.4 adds cache-aware load balancing, xgrammar structured outputs, GGUF support, LoRA in Completion API, and Intel Gaudi accelerator support.

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

$ python -m sglang_router.launch_router --policy cache_aware --worker-urls http://worker1:30000 http://worker2:30000

$ SGLANG_SET_CPU_AFFINITY=1 python -m sglang.launch_server --model-path meta-llama/Llama-3-8B-Instruct --tp 2

• ›Adds SGLANG_SET_CPU_AFFINITY environment variable to control CPU core affinity for multi-socket systems (off by default).
• ›Renames data-parallelism rank environment variable from DP_RANK to SGLANG_DP_RANK.
• ›Adds get_server_info unified API endpoint, merging three previously separate native APIs into one (also exposes SGLang version and max_total_num_tokens).
• ›Introduces cache-aware load-balancing router (sglang-router v0.0.10) delivering up to 1.9x throughput increase and 3.8x higher cache hit rate.
• ›Adds more API routes to the router (completion, health, and others previously missing).

text-generation-webui v2.0 overhauls the UI with collapsible sidebars, vertical nav, mobile support, and a new --old-colors flag.

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

$ python server.py --old-colors

• ›Adds --old-colors launch flag to restore the previous UI color scheme for users who prefer the legacy look.
• ›Allows more granular KV cache settings.
• ›Redesigns the UI with a vertical left sidebar replacing the top navigation bar (Chat / Default / Notebook tabs).
• ›Adds collapsible sidebars for improved mobile navigation.
• ›Moves the 'past chats' menu into its own sidebar, visually separated from the chat area.

vLLM v0.6.6 adds DeepSeek V3 support, online pooling API, S3 model streaming, and V1 engine milestones including VLM prefix caching.

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

$ vllm serve deepseek-ai/DeepSeek-V3 --tensor-parallel-size 8 --trust-remote-code --max-model-len 8192

• ›Adds --enable-request-id-headers flag to opt in to X-Request-ID echoing (now off by default for performance).
• ›Adds --tensor-parallel-size flag support for serving DeepSeek V3 on 8xH200 or MI300x via vllm serve deepseek-ai/DeepSeek-V3 --tensor-parallel-size 8 --trust-remote-code --max-model-len 8192.
• ›Adds Online Pooling API for embedding/pooling workloads via the V1 frontend.
• ›Supports streaming model weights from S3 using RunAI Model Streamer as an optional loader.
• ›Enables loading video inputs from base64 encoding via decord in multimodal requests.

vLLM v0.6.5 adds xgrammar guided decoding, new model support (Aria, GLM-4, Cross Encoders), AWQ/GPTQ on XPU, TPU prefix caching, and a --version CLI flag.

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

$ vllm --version

• ›Adds --version flag to the vLLM CLI for quick version inspection.
• ›Switches xgrammar as the default guided decoding backend, replacing the previous default.
• ›Adds input_audio field support in frontend requests for audio input.
• ›Adds automatic detection of chat content format from AST in the frontend, removing the need to manually specify chat format.
• ›Adds AWQ and GPTQ quantization support for the XPU backend.

Ollama v0.5.2 adds EXAONE 3.5 bilingual models (2.4B–32B) and case-insensitive OLLAMA_ORIGINS host matching.

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

• ›Adds EXAONE 3.5 instruction-tuned bilingual (English/Korean) models ranging from 2.4B to 32B parameters, developed by LG AI Research.
• ›OLLAMA_ORIGINS now matches hosts case-insensitively, simplifying origin allowlist configuration.

Ollama v0.5.0 adds JSON-schema structured outputs and experimental KV cache quantization to cut VRAM usage.

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

$ curl -X POST http://localhost:11434/api/chat -H "Content-Type: application/json" -d '{"model": "llama3.1", "messages": [{"role": "user", "content": "Tell me about Canada."}], "stream": false, "format": {"type": "object", "properties": {"name": {"type": "string"}, "capital": {"type": "string"}, "languages": {"type": "array", "items": {"type": "string"}}}, "required": ["name", "capital", "languages"]}}'

$ OLLAMA_FLASH_ATTENTION=1 OLLAMA_KV_CACHE_TYPE=q4_0 ollama serve

• ›Supports structured outputs via JSON schema in the format parameter across the REST API, Python library, and JavaScript library — constraining model responses to a defined shape.
• ›Adds Llama 3.3 (70B) model, offering performance comparable to Llama 3.1 405B.
• ›Adds Snowflake Arctic Embed 2, a multilingual frontier embedding model.
• ›Experimental OLLAMA_KV_CACHE_TYPE env var enables KV cache quantization at 4-bit (q4_0), 8-bit (q8_0), or 16-bit (f16), reducing VRAM requirements for longer context windows.

phoenix.evals now supports multimodal message templates for richer LLM evaluation inputs.

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

• ›Enables phoenix.evals to handle multimodal message templates, allowing evaluations over inputs that combine text and other media types.

Phoenix 7.2.0 improves playground template editor ergonomics.

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

• ›Enhances template editor ergonomics in the playground UI.

Phoenix 7.1.0 adds arbitrary model name entry, Gemini 2.0 Flash support, and prettier JSON rendering in the playground.

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

• ›Adds support for gemini-2.0-flash-exp as a selectable model in the Playground.
• ›Enables arbitrary string model names in the Playground, removing the restriction to a fixed model list.
• ›Prettifies JSON mimeType inputs and outputs rendered in the session details pane.

Arize Phoenix v7.0.0 ships a full Sessions feature: grouped trace views, session details UI, and a new project_sessions database table.

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

• ›Adds a project_sessions database table (via a new Alembic up migration 4ded9e43755f) to group traces into user sessions, with a back-population migration from existing spans data documented in MIGRATION.md.
• ›Adds a Sessions table on the project page showing per-session metrics including trace count, error count, trace latency percentiles (p50 and others), and last trace start time.
• ›Adds a session details page with per-session trace latency p50 and error counts.
• ›Adds navigation from an individual trace view to its parent session.
• ›Enables sorting on the sessions table.

Arize Phoenix 6.2.0 adds timeout parameters to evaluation client calls and auto-pulls prompt template variables from spans into the playground.

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

• ›Adds timeout parameters to log_evaluations and get_evaluations client methods, giving callers explicit control over request timeouts.
• ›Playground now automatically pulls prompt template variables from spans and captures them on playground spans, enabling faster replay and debugging of traced LLM calls.

Phoenix 6.1.0 adds a cancel button for playground runs and inline invocation parameter error display.

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

• ›Adds a cancel button to stop in-progress playground runs.
• ›Shows invocation parameter errors inline within the playground form instead of failing silently.

Phoenix 6.0 ships a Playground UI for interactive LLM prompt testing and adds evaluations to its OpenAPI schema.

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

• ›Adds evaluations to the OpenAPI schema, exposing evaluation data through the REST API.
• ›Releases the Playground feature — an interactive UI for running and comparing LLM prompts against live providers and datasets, with support for the AZURE_OPENAI_API_KEY environment variable for Azure OpenAI.

Langfuse v3.4.0 adds PKCE auth support, dataset score/metrics charts, full usage-type model UI, and a JSON editor toggle for text prompts.

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

$ AUTH_CUSTOM_CLIENT_AUTH_METHOD=pkce

• ›Adds AUTH_CUSTOM_CLIENT_AUTH_METHOD environment variable to enable PKCE code flow for custom OAuth/OIDC authentication clients.
• ›Adds charts for scores and resource metrics on dataset run views.
• ›Adds UI to configure all usage types when defining models.
• ›Adds a JSON editor toggle for text prompts in the prompt UI.

Langfuse v3.3.0 adds AUTH_IGNORE_ACCOUNT_FIELDS for IDP field sanitization and per-project ingestion traffic routing.

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

• ›Adds AUTH_IGNORE_ACCOUNT_FIELDS environment variable to sanitize identity-provider fields before account creation, preventing unwanted IDP data from being written to user accounts.
• ›Enables redirect of ingestion traffic for specific projects to a secondary queue, supporting traffic isolation and prioritization at the project level.
• ›Adds an organizations menu item link across all global UI pages for faster cross-organization navigation.

Langfuse v2.93.7 adds AUTH_IGNORE_ACCOUNT_FIELDS to strip unwanted IDP fields before account creation.

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

$ AUTH_IGNORE_ACCOUNT_FIELDS=role,department docker compose up

• ›Adds AUTH_IGNORE_ACCOUNT_FIELDS environment variable to sanitize specified identity-provider fields before a new account is created, preventing unwanted IDP attributes from being stored.

Langfuse v3.2.0 adds PostHog integration, flexible cost/usage key tracking, and a revamped experiment modal.

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

• ›Adds PostHog integration processing, enabling LLM observability data to flow into PostHog pipelines.
• ›Allows additional cost and usage keys in cost tracking, so custom or non-standard model billing fields can be recorded.
• ›New experiment modal in the UI highlights both prompt and custom experiments for easier navigation.

Langfuse v3.1.0 adds editable API key notes, an observations status chart, and optimistic annotation updates.

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

• ›Adds editable notes to each API key in the UI, enabling teams to document the purpose or owner of individual keys.
• ›Adds an observations status chart to the dashboard for visualizing the distribution of observation states.
• ›Introduces optimistic UI updates on the annotation form for faster, more responsive annotation workflows.

Langfuse v3 adds async worker container, Clickhouse, S3/Blob storage, and Redis for high-throughput self-hosted deployments, plus KeyCloak and GitHub Enterprise auth.

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

• ›Adds LANGFUSE_POSTGRES_INGESTION_ENABLED environment variable to control whether traces and scores are read from Postgres in v3 self-hosted deployments.
• ›Introduces a new worker container for asynchronous event processing, enabling self-hosted Langfuse to handle hundreds of events per second.
• ›Adds Clickhouse as the storage backend for traces, observations, and scores; exports and API routes (/api/public/traces, /metrics/daily) now served from Clickhouse.
• ›Adds S3/Blob store support for large object storage in self-hosted deployments, with signed AWS S3 image URLs rendered in trace/observation preview.
• ›Adds Redis/Valkey for event queuing and data caching in self-hosted setups; ingestion API rate limits doubled.

Langfuse v2.93.3 adds KeyCloak and GitHub Enterprise as authentication providers.

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

• ›Adds KeyCloak as a supported authentication provider.
• ›Adds GitHub Enterprise as a supported authentication provider.

Langfuse v2.93.1 adds an environment variable to optionally disable CSP headers.

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

• ›Adds LANGFUSE_CSP_DISABLE=true environment variable to optionally disable Content Security Policy headers.

Weave v0.51.24 adds named evals, AzureOpenAI scorer support, op code capture, and Anthropic Chat View support.

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

evaluation = weave.Evaluation(name='my-rag-eval-v1', dataset=dataset, scorers=[scorer])
await evaluation.evaluate(model)

• ›Adds AzureOpenAI support for Scorers, enabling Azure-hosted models to be used as LLM judges in evaluations.
• ›Adds option to name Weave evaluations, with automatic memorable name generation when no name is specified.
• ›Exposes a simple API to retrieve the captured source code for an op.
• ›Supports Anthropic calls in the Chat View UI for inspecting traced conversations.

Weave v0.51.23 adds VertexAI and Google GenAI integrations, Bedrock LLMs in Playground, and a new Scorers section in the side nav.

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

• ›Adds send_message patching for the Google GenAI SDK to capture traces automatically.
• ›Implements VertexAI integration for tracing calls made through the VertexAI SDK.
• ›Adds Amazon Bedrock LLMs to the Playground for interactive model testing.
• ›Adds a new scorers section to the side nav bar, enabling creation and viewing of scorers in the UI.
• ›Increases call start/end timestamp resolution to microseconds for finer-grained trace timing.

Chroma 0.5.23 introduces SPANN segment/index, hybrid read workload support, and Kubernetes query replicas.

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

• ›Introduces SPANN segment and index with append, commit, and flush operations for scalable approximate nearest-neighbor search.
• ›Adds support for RI-4 and RI-5 hybrid read workloads in chroma-load.
• ›Adds delay support on workloads in chroma-load.
• ›Adds figment-based configuration for chroma-load.
• ›Adds a chroma-load Dockerfile for containerized load testing.

LanceDB v0.14.1 adds hybrid search in async SDK, 4-bit PQ, IVF_FLAT with binary vectors, and FTS options for Node.js.

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

results = table.search(query_vector).bypass_vector_index(True).limit(10).to_list()

await db.drop_table("my_table", ignore_missing=True)

table.create_index(metric="hamming", index_type="IVF_FLAT", vector_column_name="binary_vec")

• ›Adds bypass_vector_index to the Python sync API, letting queries skip the vector index for exact search.
• ›Adds ignore_missing parameter to the async drop_table() method in Python, suppressing errors when the table does not exist.
• ›Supports Full-Text Search (FTS) options in the Node.js SDK via FtsOptions.
• ›Supports offset in the remote client, enabling paginated result retrieval against LanceDB Cloud.
• ›Supports Azure account name storage options in sync db.connect, enabling Azure Blob Storage connections by account name.

LanceDB python-v0.17.1 adds hybrid search in async SDK, 4-bit PQ, IVF_FLAT with binary vectors, and async/sync Table parity.

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

results = table.search(query_vector).bypass_vector_index(True).limit(10).to_list()

await db.drop_table("my_table", ignore_missing=True)

• ›Adds bypass_vector_index to the sync query API, letting callers force a brute-force scan instead of using an ANN index.
• ›Adds ignore_missing parameter to the async drop_table() method, suppressing errors when the table does not exist.
• ›Adds FTS (full-text search) options support to the Node.js SDK.
• ›Supports hybrid search in the async Python SDK, bringing it to parity with the sync SDK.
• ›Supports offset in the remote client, enabling paginated result retrieval against LanceDB Cloud.

LanceDB python-v0.17.1-beta.5 brings async-sync feature parity on the Table API.

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

• ›Adds async-sync feature parity on the Table class, enabling all synchronous Table operations to have async equivalents.

LanceDB v0.14.1-beta.5 brings async-sync feature parity on the Python Table API.

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

• ›Adds async-sync feature parity on the Python Table class, enabling the same operations across both synchronous and asynchronous usage patterns.

LanceDB python-v0.17.1-beta.4 adds FTS options support in Node.js and upgrades to lance 0.21.0b3.

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

• ›Supports full-text search (FTS) options in the Node.js client.
• ›Upgrades the underlying lance engine to version 0.21.0b3.

LanceDB v0.14.1-beta.4 adds full-text search options for the Node.js client and upgrades the Lance core to 0.21.0b3.

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

• ›Adds FTS (full-text search) options support to the Node.js client, bringing parity with other language bindings for configuring full-text search behavior.
• ›Upgrades the underlying Lance core library to version 0.21.0b3.

LanceDB v0.14.1-beta.2 adds offset support in the remote client and 4-bit Product Quantization indexing.

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

• ›Supports 4-bit Product Quantization (PQ) for ANN indexes, reducing memory footprint for large vector datasets.
• ›Adds offset support in the remote client, enabling paginated query results against LanceDB Cloud.

LanceDB python-v0.17.1-beta.2 adds offset support in the remote client and 4-bit PQ index compression.

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

• ›Supports offset in remote client queries, enabling paginated result retrieval against remote LanceDB instances.
• ›Supports 4-bit Product Quantization (PQ) for vector indexes, reducing memory and storage requirements for large-scale ANN search.

LanceDB v0.14.1-beta.0 adds hybrid search to the async Python SDK and Azure account name storage support.

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

import lancedb

db = lancedb.connect(
    "az://my-container/my-db",
    storage_options={"account_name": "mystorageaccount"}
)

• ›Supports account_name as an Azure storage option in synchronous db.connect calls.
• ›Adds hybrid search support to the async Python SDK.

LanceDB python-v0.17.1-beta.0 adds hybrid search in the async SDK and Azure account name storage options for sync connections.

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

import lancedb

db = lancedb.connect(
    "az://my-container/my-db",
    storage_options={"account_name": "mystorageaccount"}
)

• ›Adds account_name as an Azure storage option in the synchronous db.connect call, enabling Azure Blob Storage authentication by account name.
• ›Supports hybrid search in the async SDK, bringing parity with the sync SDK for combined vector and full-text search workflows.

LanceDB v0.14.0 adds schema evolution APIs, multimodal Voyage embeddings, Azure OpenAI, PyArrow dataset adapter, and FTS options on RemoteTable across all SDKs.

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

• ›Adds ef search parameter support for HNSW index queries, controllable at query time.
• ›Adds checkout and checkout_latest to remote SDKs for version-pinned table access.
• ›Adds list_versions to TypeScript, Rust, and remote Python SDKs for enumerating table versions.
• ›Adds overwrite and exist_ok modes for create_table on remote connections.
• ›Adds FTS options support on RemoteTable, enabling full-text search configuration for remote backends.

LanceDB python-v0.17.0 adds schema evolution APIs, PyArrow dataset adapter, Azure OpenAI SDK, Voyage multimodal embeddings, and remote SDK parity.

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

import lancedb
import pyarrow.dataset as ds

db = lancedb.connect("./mydb")
table = db.open_table("embeddings")
dataset = table.to_arrow_dataset()
batches = dataset.to_batches()

• ›Adds ef search parameter support for HNSW queries, configurable at query time.
• ›Adds checkout and checkout_latest methods to remote SDKs for version pinning.
• ›Adds list_versions to the TypeScript, Rust, and remote Python SDKs.
• ›Adds overwrite and exist_ok mode options for remote create_table.
• ›Adds schema evolution APIs across all SDKs — Python, TypeScript, and Rust.

LanceDB python-v0.17.0-beta.3 adds multimodal Voyage embeddings, a PyArrow dataset adapter, and remote DB folder-prefix URI support.

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

• ›Adds a PyArrow dataset adapter for LanceDB tables, enabling LanceDB tables to be consumed directly as pyarrow.dataset.Dataset objects.
• ›Adds multimodal capabilities to the Voyage embedder, allowing image and text inputs to be embedded together via the Voyage integration.
• ›Supports folder-prefix paths in remote DB URIs, enabling scoped access to a subdirectory within a remote LanceDB store.

LanceDB v0.14.0-beta.2 adds multimodal Voyage embeddings, a PyArrow dataset adapter, and remote DB URI folder prefixes.

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

• ›Adds a PyArrow dataset adapter for LanceDB tables, enabling LanceDB tables to be used directly as PyArrow datasets.
• ›Adds multimodal capabilities to the Voyage embedder, enabling embedding of non-text modalities via Voyage.
• ›Adds folder prefix support for remote database URI paths.

Milvus 2.5 adds full-text search (BM25), bitmap indexes, nullable fields, CSV import, clustering compaction, and a cluster management WebUI.

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

from pymilvus import MilvusClient, DataType

client = MilvusClient(uri="http://localhost:19530")
schema = client.create_schema()
schema.add_field("id", DataType.INT64, is_primary=True, auto_id=True)
schema.add_field("embedding", DataType.FLOAT_VECTOR, dim=128)
schema.add_field("category", DataType.VARCHAR, max_length=64, nullable=True, default_value="unknown")
client.create_collection("products", schema=schema)

from pymilvus import MilvusClient, DataType

client = MilvusClient(uri="http://localhost:19530")
schema = client.create_schema()
schema.add_field("id", DataType.INT64, is_primary=True, auto_id=True)
schema.add_field("region_id", DataType.INT64, is_clustering_key=True)
schema.add_field("embedding", DataType.FLOAT_VECTOR, dim=256)
client.create_collection("geo_vectors", schema=schema)

• ›Supports nullable=True and default values for scalar fields, allowing null data to be omitted on insert without errors.
• ›Adds CSV bulk import format alongside the existing JSON and Parquet support.
• ›Introduces Clustering Compaction (Beta): specifying a scalar field as a clustering key redistributes data by range, enabling efficient pruning during queries when scalar filters are applied.
• ›Introduces Full Text Search via built-in Sparse-BM25 (Tantivy-powered), with built-in analyzers and sparse vector extraction so collections can accept raw text instead of pre-computed vectors.
• ›Adds Text Match capability using Tantivy-based analyzers and indexing for precise term-level natural language filtering within vector searches.

Milvus 2.4.18 adds customizable RBAC privilege groups, a new Grant/Revoke API, and RESTful expression templates.

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

• ›New Grant/Revoke API lets callers grant or revoke privileges without specifying an ObjectType, using privilege group names directly.
• ›alterindex and altercollection now support modifying index and collection properties at runtime.
• ›alterdatabase now supports deleting database properties.
• ›Adds expression template support for RESTful API query/search requests, enabling parameterized expressions.
• ›Adds database-scoped requests to the RESTful API.

Weaviate v1.26.12 adds VoyageAI multimodal embeddings, Ollama batch support, and a runtime log-level API.

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

• ›Supports runtime log-level configuration via the API, enabling operators to adjust verbosity without restarting the service.
• ›Adds support for the Ollama batch endpoint, improving throughput for Ollama-backed vectorization.
• ›Adds a new VoyageAI multimodal module, enabling image and text embeddings through VoyageAI.
• ›Adds support for X-Goog-* headers in Google provider clients.
• ›Adds environment variable overrides for Azure backup block size and concurrency settings.

Weaviate v1.25.28 adds a VoyageAI multimodal module for embedding multimodal content.

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

• ›Adds a VoyageAI multimodal module, enabling multimodal embeddings via VoyageAI within Weaviate.

Weaviate v1.27.8 adds a VoyageAI multimodal module for cross-modal vector search.

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

• ›Adds the VoyageAI multimodal module, enabling vectorization of mixed-modality content via VoyageAI's embedding models.

Weaviate v1.27.7 adds reindex-references API, maintenance-mode toggle, Azure env overrides, and X-Goog-* header support.

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

• ›Adds environment variable overrides for Azure block size and concurrency settings.
• ›Adds support for X-Goog-* headers, enabling Google-specific header passthrough.
• ›Adds an option to skip waiting for self-deployed modules on startup.
• ›Limits backup search scope to BACKUP_PATH for remote backends, reducing unintended traversal.
• ›Adds a reindex-references feature via the debug API to rebuild reference indexes.

Weaviate v1.25.27 adds environment overrides for Azure block size and concurrency, plus an option to skip waiting for self-deployed modules.

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

• ›Adds environment overrides for Azure block size and concurrency settings.
• ›Adds an option to not wait for self-deployed modules on startup.
• ›Adds support for X-Goog-* headers in API requests.

Composio v0.6.8 adds retry support in Action postprocessor and connected_account access in custom actions.

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

• ›Supports requesting connected_account inside custom actions, enabling action authors to access the connected account context at runtime.
• ›Adds retry support in the Action postprocessor, allowing failed action post-processing steps to be retried automatically.

Composio v0.6.7 adds trigger list support and expands SQL tooling with SQLite and remote database connections.

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

• ›Adds trigger list support, enabling enumeration of available triggers via the Composio client.
• ›Enhances the SQL Query Tool with SQLite and remote database support, broadening the range of data sources accessible through Composio actions.

Composio v0.6.4 adds SDR kit agents, initiate connection support, and TypeScript exports.

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

• ›Adds SDR (Sales Development Representative) kit agents for automated outreach workflows.
• ›Adds initiate connection support and new TypeScript exports to the SDK.
• ›Updates the Phidata plugin to support the use toolkit interface.
• ›Reduces TypeScript bundle size and brings ESLint and TypeScript issues to zero.

Composio v0.6.0 adds processor support, bundler support, object params for methods, and remove-integration capability.

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

• ›Adds processor support alongside a move to object params for methods, enabling pre/post-processing of tool calls.
• ›Adds bundler support for the JavaScript SDK.
• ›Adds remove integration support via the CLI/SDK.
• ›Revamps the composio apps update CLI command.
• ›Improves 400-error handling with richer error messages.

Composio v0.5.51 adds advanced use-case search in the JS SDK, workflow dispatch, LangGraph integration, and x-request-id propagation.

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

• ›Passes x-request-id header in all Composio API queries, enabling request tracing across distributed calls.
• ›Adds advanced use-case search functionality in the JS SDK.
• ›Adds workflow dispatch support with improved logging level controls.
• ›Adds LangGraph integration for both Python and TypeScript.
• ›Makes beta enum generation the default behavior.