The AI Toolchain — issue -376, July 31, 2024

Aider v0.46.0 adds /ask and /chat-mode commands, always-load file config, and improved token cost reporting.

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

$ aider
/ask What does the authentication flow in auth.py do?

# .aider.conf.yml
file: CONVENTIONS.md

$ /chat-mode help

• ›New /ask <question> command lets you query your codebase without triggering any edits.
• ›New /chat-mode <mode> command switches between ask, code, and help interaction modes mid-session.
• ›Supports file: key in .aider.conf.yml to always load one or more files into every chat session.
• ›Enhanced token usage and cost reporting now works during streaming responses.
• ›Filename auto-complete for /add and /drop is now case-insensitive.

Aider v0.45.0 adds GPT-4o mini support and exposes last 4 chars of API keys in verbose output.

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

• ›Supports GPT-4o mini, which scores comparably to GPT-3.5 on the code editing benchmark using whole edit format.
• ›Improved file-add suggestions on Windows when aider detects relevant files not yet in the chat.
• ›Shows last 4 characters of API keys in --verbose output for easier key identification.

Aider v0.44.0 slashes install size by up to 12x and introduces optional package extras for help, browser, and Playwright.

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

$ aider --just-check-updated

• ›Reduces default pip install size by 3–12x, making minimal installs practical in constrained environments.
• ›Adds three optional package extras (aider-chat[help], aider-chat[browser], aider-chat[playwright]) that Aider will prompt to install on demand.
• ›Simplifies the output of --models for easier model browsing.

Aider v0.43.0 adds in-chat help, multi-undo, and standardized config file loading from multiple paths.

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

$ /help How do I set a custom model settings file?

• ›Adds /help <question> command to ask questions about usage, settings, troubleshooting, and LLM configuration directly inside the chat session.
• ›Default --model-settings-file path is now .aider.model.settings.yml.
• ›Default --model-metadata-file path is now .aider.model.metadata.json.
• ›All config, env, YAML, and JSON files now load from home directory, git root, current working directory, and a named command-line switch — enabling layered configuration.
• ›Introduces $HOME/.aider/caches as a new directory for app-wide expendable caches.

Aider v0.41.0 defaults to Claude 3.5 Sonnet, adds >4k token streaming, image support, and commit message prefixing.

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

$ aider --attribute-commit-message

• ›Adds --attribute-commit-message flag to prefix aider's commit messages with 'aider:'.
• ›Aider now defaults to claude-3-5-sonnet-20240620 when ANTHROPIC_API_KEY is set in the environment.
• ›Enables streaming responses greater than 4k tokens for Claude 3.5 Sonnet, unlocking large refactors and multi-file code generation in a single pass.
• ›Adds image support for Claude 3.5 Sonnet and for GPT-4o and Claude 3.5 Sonnet via OpenRouter.
• ›Automatically retries requests on Anthropic overloaded_error responses.

Cline v1.0.4 adds analyze_project tool, user feedback on tool use, 8192-token output, and API retry support.

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

$ Claude Dev: Open In New Tab

• ›New analyze_project tool gives Claude a comprehensive overview of project source code definitions and file structure.
• ›Enables user feedback on tool use actions such as terminal commands and file edits.
• ›Raises max output tokens to 8192, reducing truncated or placeholder code responses.
• ›Adds ability to retry failed API requests, improving resilience against rate limits.
• ›Open-in-editor view (via menu bar or Claude Dev: Open In New Tab command palette entry) shows workspace changes more clearly.

OpenHands 0.8.0 adds user confirmation mode, per-agent LLM config, EventStream runtime with browser and Jupyter support, and restores append_file.

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

• ›Adds append_file action back to the agent's file-editing toolkit, enabling agents to append content to files without overwriting them.
• ›Implements user confirmation mode: when enabled, OpenHands requests explicit user confirmation before executing bash or Python code.
• ›Enables per-agent LLM configuration, allowing each delegated agent to use a distinct LLM config set from the UI.
• ›Introduces EventStreamRuntime with an agnostic sandbox, adding Jupyter notebook support and browser interaction to the runtime client.
• ›Adds a WebSocket runtime (od-client-runtime) as a new runtime backend option.

OpenHands 0.7.1 adds local Ollama model support, CLI session restore, config templates, and DEBUG logging control.

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

• ›Adds make run-wsl target for running OpenHands under Windows Subsystem for Linux.
• ›Enables DEBUG-level logging via a config setting, giving operators fine-grained log control without code changes.
• ›Adds a config template feature to bootstrap new configuration files.
• ›Adds support for local Ollama models, letting teams run inference entirely on-premises without an external LLM provider.
• ›Adds optional CLI session restore, allowing interrupted CLI sessions to be resumed.

Zed v0.145.1 ships Remote Development over SSH, a /symbols assistant command, gpt-4o-mini support, and file-icon tabs.

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

{ "tabs": { "file_icons": true } }

{ "show_signature_help_after_completion": false }

{ "use_system_path_prompts": false }

• ›Adds "show_signature_help_after_completion": false to settings.json to disable the new function signature popovers.
• ›Adds "tabs": { "file_icons": true } to settings.json to show file icons on buffer tabs.
• ›Adds use_system_path_prompts setting (default true) to settings.json; set to false to use Zed's built-in keyboard-driven file prompts instead of XDG/system pickers.
• ›Adds /symbols slash command in the assistant panel, which automatically inserts the active file's symbols into the assistant context.
• ›Launches Remote Development (alpha) for all users — edit files or run commands on a remote server over SSH, with collaboration support.

Zed v0.144.3 adds native snippet support for all buffers, outline panel filtering, and tailwindcss-language-server classAttributes config.

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

{
  "lsp": {
    "tailwindcss-language-server": {
      "settings": {
        "classAttributes": ["class", "className", "ngClass", "styles"]
      }
    }
  }
}

• ›Adds classAttributes key under lsp.tailwindcss-language-server.settings in Zed config, letting you declare which attributes Tailwind scans (e.g. class, className, ngClass, styles).
• ›Extensions can now ship snippets by including a snippets.json file alongside the extension manifest.
• ›Moves snippet support into the core editor so snippets work in any buffer, including plain text — deprecates the separate snippet extension.
• ›Adds filtering support in the outline panel.
• ›Adds dynamic registration and unregistration of LSP formatting capabilities.

Zed lands on Linux with macro support, new AI action, IBM Plex fonts, and updated keybindings

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

• ›Adds assistant: insert into editor action (keybinding: cmd-< on macOS, ctrl-< on Linux) to insert AI output directly into the editor.
• ›Adds keyboard shortcuts for scrolling in the terminal.
• ›Changes default key binding for page-down to move the cursor via editor::MovePageDown; previous scroll-only behavior (editor::PageDown) is now bound to cmd-pagedown on macOS and alt-pagedown on Linux.
• ›Adds shift shift as a default binding to open the command palette in the JetBrains keymap.
• ›Adds duplicate-line shortcut to the Sublime Text keymap.

Zed v0.142.4 adds Claude 3.5 Sonnet support, customizable OpenAI-compatible models, and new editor settings including scroll_beyond_last_line and gutter.runnables.

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

"assistant": {
  "version": "1",
  "provider": {
    "default_model": "claude-3-5-sonnet",
    "name": "anthropic"
  }
}

• ›Adds Claude 3.5 Sonnet (claude-3-5-sonnet) as a supported model via the assistant config block with "name": "anthropic" and "default_model": "claude-3-5-sonnet".
• ›Adds scroll_beyond_last_line setting to control whether the editor scrolls past the final line.
• ›Adds gutter.runnables setting to control whether runnable indicators are displayed in the gutter.
• ›Adds active_line_width setting to configure the line width of the active indent guide.
• ›Adds ability to customize available models for OpenAI-compatible services.

CrewAI v0.36.0 adds AgentOps native support, Firecrawl Tools, and tool-result-as-agent-result capability

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

• ›Adds native AgentOps integration for agent observability and monitoring.
• ›Adds Firecrawl Tools for web scraping and crawling within CrewAI agents.
• ›Adds the ability to return a tool's result directly as an agent result.
• ›Improves the coding Interpreter tool.
• ›Adds the ability to create a custom converter class.

DSPy v2.4.12 lets you compile dspy.Predict and dspy.ChainOfThought directly and improves Chat LM adapter support.

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

• ›Supports compiling dspy.Predict and dspy.ChainOfThought directly as Modules without wrapping them in a dspy.Module object.
• ›Improves the experimental=True Chat LM adapter support (enabled via dspy.configure(experimental=True)) introduced in v2.4.11, refining zero-shot generation quality for Chat LMs including GPT-3.5, GPT-4, Llama3, Mixtral, and DBRX.

DSPy v2.4.11 adds experimental adapter support for smoother Chat LM zero-shot generation via dspy.configure(experimental=True)

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

import dspy
dspy.configure(experimental=True)

• ›Enables dspy.configure(experimental=True) to activate new adapter support, improving zero-shot generation predictability and accuracy for Chat LMs including GPT-3.5, GPT-4, Llama3, Mixtral, and DBRX.
• ›Adds initial support for new adapters with improved handling of Chat LM interactions.

Haystack v2.2.4 adds filter_policy to in-memory retrievers for flexible runtime filter control.

$ git clone --branch v2.2.4 https://github.com/deepset-ai/haystack.git
# already have the repo? check out this version:
$ git checkout v2.2.4

from haystack.components.retrievers.in_memory import InMemoryBM25Retriever

retriever = InMemoryBM25Retriever(
    document_store=document_store,
    filter_policy='merge'
)

• ›Introduces filter_policy init parameter for InMemoryBM25Retriever and InMemoryEmbeddingRetriever, accepting 'replace' or 'merge' to control how runtime filters interact with initial filters.
• ›Adds apply_filter_policy function to standardize filter-policy application across all document store-specific retrievers, enabling consistent replace/merge behavior.

langchain-anthropic 0.1.22 adds ToolMessage.status and TypedDict-to-tool-schema conversion support.

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

• ›Introduces ToolMessage.status field on ToolMessage to carry status information for tool call results.
• ›Adds support for converting TypedDict types directly to tool schemas, enabling TypedDict-defined inputs to be used as tool definitions.

langchain-core 0.2.26 adds support for using TypedDict to define tool schemas.

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

• ›Supports converting TypedDict classes into tool schemas, enabling typed Python dicts to be used directly when defining tools.

langchain-core 0.2.25 adds ToolMessage.status field and support for non-pickleable tool call arguments.

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

• ›Adds ToolMessage.status field to represent the status of a tool message.
• ›Supports tool calls with non-pickleable arguments in tools, broadening the range of objects that can be passed as tool call inputs.

langchain-openai adds support for the gpt-4o-mini model

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

• ›Adds gpt-4o-mini as a supported model in the OpenAI integration.

LangChain Core 0.2.24 adds rate limiting abstractions and async support for InMemoryVectorStore

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

from langchain_core.rate_limiters import InMemoryRateLimiter
from langchain_openai import ChatOpenAI

rate_limiter = InMemoryRateLimiter(requests_per_second=2)
llm = ChatOpenAI(model='gpt-4o', rate_limiter=rate_limiter)
response = llm.invoke('Summarize this document.')

from langchain_core.vectorstores import InMemoryVectorStore
from langchain_openai import OpenAIEmbeddings
import asyncio

store = InMemoryVectorStore(embedding=OpenAIEmbeddings())
await store.aadd_texts(['doc one', 'doc two', 'doc three'])
results = await store.asimilarity_search('relevant query', k=2)

• ›Adds rate_limiter field to BaseModel along with a RateLimiter abstraction and InMemoryRateLimiter in-memory implementation for controlling request throughput to LLMs.
• ›Adds asynchronous support to InMemoryVectorStore, enabling non-blocking vector similarity operations in async LangChain pipelines.
• ›Aligns ChatPromptTemplate.__init__ behavior with ChatPromptTemplate.from_messages, so both construction paths are now equivalent.

LangChain CLI 0.0.26 adds a conversation memory combining persistent vectorstore history with a token buffer.

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

• ›Adds a conversation memory type that combines an optionally persistent vectorstore history with a token buffer for richer, scalable chat context management.

langchain-qdrant 0.1.3 adds async similarity search with relevance scores to the Qdrant class.

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

• ›Adds _asimilarity_search_with_relevance_scores method to the Qdrant class for async similarity search returning relevance scores.

LangChain Experimental 0.0.63 adds prompt restrictions for non-function-calling LLMs in LLMGraphTransformer and tightens PALValidator blocking.

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

• ›Adds conditional logic in LLMGraphTransformer to inject restrictions into prompts for LLMs that do not support function calling, enabling graph extraction with a broader set of models.
• ›Expands PALValidator to block additional unsafe constructs, hardening code execution paths in PAL chains.

langchain-community 0.2.10 adds dedoc-based document loaders, a link-extraction document transformer, and a progress-bar toggle flag.

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

• ›Adds new document loaders based on the dedoc library for parsing a wide range of document formats.
• ›Adds a new document transformer for extracting links from documents.
• ›Adds a flag to toggle the progress bar on document loading operations.

LangChain 0.2.11 adds async methods to ConversationSummaryBufferMemory and relaxes multi-agent return_direct validation.

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

• ›Adds async methods to ConversationSummaryBufferMemory, enabling non-blocking memory summarization in async LangChain pipelines.
• ›Removes return_direct validation restriction in multi-agent setups, allowing agents to use return_direct without triggering an error.
• ›Updates ContextualCompressionRetriever base_retriever type to RetrieverLike, broadening the range of retriever objects accepted.

langchain-core 0.2.23 relaxes tool/parser type constraints and enables RunnableWithMessageHistory without config

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

• ›Enables RunnableWithMessageHistory to run without requiring an explicit config argument.
• ›Accepts configurable keys at the top level, reducing nesting when passing configuration.
• ›Relaxes type-checking constraints on tools and parsers, allowing broader input types.

langchain-community 0.2.9 adds MongoDB byte store, Riza code execution, TextEmbed, ApertureDB, and new graph/link-extraction integrations

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

from langchain_community.chat_message_histories import FileChatMessageHistory

history = FileChatMessageHistory(
    file_path="chat_history.json",
    file_encoding="utf-8",
    json_encoding="utf-8"
)

from langchain_community.storage import MongoDBByteStore

store = MongoDBByteStore(
    connection_string="mongodb://localhost:27017",
    db_name="langchain",
    collection_name="byte_store"
)

• ›Adds file_encoding and json_encoding parameters to FileChatMessageHistory for specifying character and JSON encoding when persisting chat histories.
• ›Adds MongoDBByteStore as a new byte store backend for MongoDB.
• ›Adds RizaCodeInterpreter tool for Python and JavaScript code execution via the Riza API.
• ›Adds TextEmbedEmbeddings integration for the TextEmbed embedding service.
• ›Adds ApertureDB as a new vector store backend.

LangChain 0.2.10 adds aadd_documents to ParentDocumentRetriever, a new ListRerank document compressor, and seed control for evaluations.

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

await retriever.aadd_documents(documents)

• ›Adds aadd_documents async method to ParentDocumentRetriever for non-blocking document ingestion.
• ›Adds ListRerank document compressor for reranking retrieved documents using a list-based approach.
• ›Passes seed directly into evaluation runs for reproducible LLM evaluation results.

langchain-mongodb 0.1.7 adds index creation helpers, string ID support, and custom options for MongoDBChatMessageHistory.

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

• ›Adds experimental driver-side index creation helper to MongoDBVectorSearch for programmatic index management without leaving Python.
• ›Adds string ID support to MongoDBVectorSearch — the vectorstore now accepts and returns string IDs instead of requiring ObjectId types.
• ›Adds custom options support to MongoDBChatMessageHistory, allowing callers to pass additional configuration when constructing chat history instances.

LangChain Core 0.2.22 adds Pydantic v1 and v2 BaseModel support in argsschema.

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

• ›Supports all versions of Pydantic BaseModel in argsschema, enabling tools and chains to accept both Pydantic v1 and v2 model schemas without conversion.

langchain-core 0.2.21 adds InjectedToolArg annotation for marking tool arguments as runtime-injected.

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

from langchain_core.tools import tool
from langchain_core.tools.base import InjectedToolArg
from typing import Annotated

@tool
def get_user_data(query: str, user_id: Annotated[str, InjectedToolArg]) -> str:
    """Fetch data for the current user."""
    return f"Data for {user_id}: {query}"

• ›Adds InjectedToolArg annotation to mark tool arguments that should be injected at runtime rather than supplied by the model.

langchain-openai 0.1.17 exposes raw response headers from OpenAI API calls.

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

• ›Exposes raw HTTP response headers returned by the OpenAI API, enabling access to metadata such as rate-limit and request-ID headers.

LangChain 0.2.9 adds similarity_score_threshold search type support to MultiVectorRetriever.

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

• ›Adds similarity_score_threshold as a supported search type for MultiVectorRetriever, enabling relevance-filtered retrieval.

langchain-core 0.2.20 adds encoding options for file-based prompt templates and expands message utils for LCEL compatibility.

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

• ›Adds encoding options when creating a prompt template from a file, enabling non-UTF-8 source files to be loaded correctly.
• ›Extends message utility functions to work with LCEL (LangChain Expression Language) pipelines.
• ›Updates template format typing to include jinja2 as a Literal value alongside the existing options.

LangChain 0.2.8 adds configurable generic model support, document_variable_name param, and ToolCall/ToolMessage I/O for Tools.

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

from langchain.chains.combine_documents import create_stuff_documents_chain

chain = create_stuff_documents_chain(
    llm=llm,
    prompt=prompt,
    document_variable_name="context"
)

from langchain.chat_models import init_chat_model

model = init_chat_model("gpt-4o", model_provider="openai")
response = model.invoke("Summarize the latest threat report.")

• ›Adds document_variable_name parameter to create_stuff_documents_chain, letting callers explicitly name the prompt variable that receives the stuffed documents.
• ›Introduces a generic configurable model via init_chat_model, enabling runtime model selection without changing chain code.
• ›Supports ToolCall as Tool input and ToolMessage as Tool output, aligning tool invocation with the structured message types used by chat models.

langchain-core 0.2.19 adds args_schema support to as_tool() and includes tool name in tool messages.

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

• ›Adds args_schema parameter support to the as_tool method, allowing callers to pass a custom schema that controls how tool arguments are validated and described.
• ›Adds tool name field to tool messages, making it easier to trace which tool produced a given message in multi-tool chains.

langchain-qdrant 0.1.2 ships a new Qdrant implementation and a new sparse embeddings provider interface.

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

• ›Introduces a new Qdrant implementation replacing the prior integration internals.
• ›Adds a new sparse embeddings provider interface (Part 1), enabling sparse vector support in Qdrant-backed retrievers.

langchain-anthropic 0.1.20 adds support for ToolCall as Tool input and ToolMessage as Tool output

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

• ›Supports ToolCall as Tool input and ToolMessage as Tool output, enabling direct round-trip tool-calling workflows between Anthropic models and LangChain tools.

langchain-openai 0.1.16 adds native support for ToolCall as Tool input and ToolMessage as Tool output.

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

• ›Supports ToolCall objects as direct input to Tools and ToolMessage objects as Tool output, enabling richer, more structured tool-call round-trips in LLM pipelines.

langchain-fireworks 0.1.5 adds ToolCall-as-input and ToolMessage-as-output support for Tools

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

• ›Supports ToolCall as Tool input and ToolMessage as Tool output, enabling structured round-trip tool-calling workflows with Fireworks-backed models.
• ›Reads tool invocation results from the tool_calls attribute on model responses.

LangChain MistralAI 0.1.10 adds support for ToolCall as Tool input and ToolMessage as Tool output.

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

• ›Supports ToolCall as Tool input and ToolMessage as Tool output, enabling structured tool-calling round-trips in MistralAI-backed chains.

LangChain Core 0.2.16 lets Tools accept ToolCall inputs and return ToolMessage outputs.

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

• ›Tools now accept ToolCall objects directly as input and can return ToolMessage objects as output, enabling richer, structured tool-call workflows across LangChain integrations.

langchain-core 0.2.15 adds custom event dispatching and richer Mermaid graph metadata rendering.

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

• ›Adds dispatching for custom events, enabling components to emit and handle user-defined events in the LangChain event stream.
• ›Propagates parse_docstring to the tool decorator so tool descriptions are automatically extracted from function docstrings.
• ›Renders metadata key-value pairs when drawing Mermaid graphs, and includes metadata in the graph JSON representation.
• ›Adds as_tool method version annotation via versionadded for clearer API documentation.

LangChain Core 0.2.13 adds Runnable-to-tool conversion and a new ToolMessage.raw_output field.

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

from langchain_core.messages import ToolMessage

msg = ToolMessage(content='42', raw_output={'result': 42, 'status': 'ok'}, tool_call_id='call_1')
print(msg.raw_output)

• ›Adds ToolMessage.raw_output field to capture the raw output from a tool invocation alongside the serialized message content.
• ›Supports conversion of Runnables to tools, enabling any Runnable to be used directly as a tool in an agent or chain.
• ›Moves JSON parsing in the base chat model and output parser to a background thread, unlocking non-blocking parsing for large payloads.

langchain-community 0.2.7 adds PGVector support in PebbloRetrievalQA, SingleStoreDB semantic cache, bind_tools for ChatLiteLLM, and Jira cloud/token auth.

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

from langchain_community.utilities.jira import JiraAPIWrapper

wrapper = JiraAPIWrapper(
    jira_instance_url='https://myorg.atlassian.net',
    jira_api_token='<your-token>',
    cloud=True
)

from langchain_community.chat_models.litellm import ChatLiteLLM

llm = ChatLiteLLM(model='gpt-4')
llm_with_tools = llm.bind_tools([my_tool])

from langchain_community.cache import SingleStoreDBSemanticCache
import langchain

langchain.llm_cache = SingleStoreDBSemanticCache(
    embedding=my_embeddings,
    host='<singlestore-host>',
    port=3306,
    user='<user>',
    password='<password>',
    database='<db>'
)

• ›Adds cloud parameter to JiraAPIWrapper to support Jira Cloud instances alongside server deployments.
• ›Adds model_name parameter to GPT4AllEmbeddings for explicit model selection.
• ›Adds bind_tools function to ChatLiteLLM for structured tool-calling support.
• ›Adds tool_calls response support to the community tool-calls integration.
• ›Adds SingleStoreDB semantic cache via SingleStoreDB integration.

LangChain 0.2.7 adds a conversation memory that combines a persistent vectorstore history with a token buffer.

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

• ›Adds a new conversation memory type that combines an optionally persistent vectorstore history with a token buffer, enabling long-term retrieval-augmented memory alongside recent-context windowing.

langchain-core 0.2.12 adds GraphStore, VectorStore upsert methods, and InMemoryChatMessageHistory to core.

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

from langchain_core.vectorstores import VectorStore

# synchronous upsert
vectorstore.upsert(documents)

# async streaming upsert for large batches
async for result in vectorstore.astreaming_upsert(documents):
    print(result)

from langchain_core.chat_history import InMemoryChatMessageHistory

history = InMemoryChatMessageHistory()
await history.aadd_messages([HumanMessage(content="Hello")])
print(history.messages)

• ›Adds upsert, streaming_upsert, aupsert, and astreaming_upsert methods to the VectorStore abstraction for writing documents with conflict-resolution semantics.
• ›Adds Graph Store component to langchain-core, enabling graph-based retrieval as a first-class abstraction.
• ›Moves InMemoryChatMessageHistory into langchain-core (previously in langchain-community), making it available without the community package.
• ›Extends conversion utilities to handle RemoveMessage, enabling message deletion in conversation history workflows.
• ›Unifies function schema parsing across the core library for consistent tool-call handling.

langchain-openai 0.1.14 exposes the model request payload for OpenAI calls.

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

• ›Exposes the model request payload sent to OpenAI, giving callers visibility into the exact data submitted per request.

langchain-core 0.2.11 adds vector store batch lookup, in-memory cache size limits, a BaseMedia type, and optional Document IDs.

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

docs = vectorstore.get_by_ids(["doc-001", "doc-002", "doc-003"])

from langchain_core.caches import InMemoryCache
cache = InMemoryCache(maxsize=1000)

• ›Adds get_by_ids method to the VectorStore base interface, enabling batch retrieval of documents by ID.
• ›Adds maxsize parameter to InMemoryCache to cap memory usage.
• ›Adds optional id field to the Document schema for explicit document identification.
• ›Introduces BaseMedia base object as a new type in the core schema.
• ›Adds RemoveMessage to support removing messages from conversation state.

langchain-ai21 0.1.7 adds streaming support for AI21 Labs Jamba models.

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

• ›Adds streaming support for AI21 Labs Jamba models.

langchain-anthropic 0.1.18 adds stop_reason to ChatAnthropic streaming results.

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

• ›Adds stop_reason field to ChatAnthropic stream result chunks, surfacing why the model stopped generating.

LangGraph 0.1.10 adds InjectedState for automatic graph-state injection into tools and improves parallel tool execution in ToolNode.

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

from typing import Annotated
from langgraph.prebuilt.tool_node import InjectedState
from langchain_core.tools import tool

class AgentState(TypedDict):
    messages: list
    user_id: str

@tool
def lookup_policy(
    topic: str,
    state: Annotated[AgentState, InjectedState()],
) -> str:
    """Look up company policy, scoped to the current user."""
    user_id = state["user_id"]  # injected automatically; model never sees it
    return fetch_policy(topic, user_id)

• ›Adds InjectedState annotation to automatically inject graph state into tool arguments inside ToolNode, so tools can access state fields without the model generating them.
• ›Improves parallel execution of tools in ToolNode using config lists via get_config_list from langchain-core.
• ›Adds GraphInterrupt error class for structured handling of interruptions in nested graphs.
• ›Adds EmptyInputError error class for clearer reporting when graphs receive empty inputs.
• ›Enhances checkpoint parent-child relationship tracking and includes parent configuration data in checkpoint tuples, improving support for nested graphs.

LangGraph 0.1.9 adds state_modifier to create_react_agent, custom state schemas, retry policies, and new background executor classes.

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

from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI

def modify_state(state):
    # state is the full graph state, not just messages
    return [{"role": "system", "content": "You are a helpful security analyst."}] + state["messages"]

agent = create_react_agent(
    model=ChatOpenAI(model="gpt-4o"),
    tools=[...],
    state_modifier=modify_state,
)

from typing import TypedDict, Annotated
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI
import operator

class MyAgentState(TypedDict):
    messages: Annotated[list, operator.add]
    user_role: str          # custom field
    session_id: str         # custom field

agent = create_react_agent(
    model=ChatOpenAI(model="gpt-4o"),
    tools=[...],
    state_schema=MyAgentState,
)

• ›Adds state_modifier parameter to create_react_agent for finer control over LLM inputs, replacing the now-deprecated messages_modifier.
• ›Adds state_schema parameter to create_react_agent, enabling custom graph state definitions beyond the default AgentState.
• ›Adds BackgroundExecutor and AsyncBackgroundExecutor classes in langgraph.pregel for structured background task management and cancellation.
• ›Adds retry policies for nodes in StateGraph.
• ›Adds custom input and output type support to StateGraph.

LangGraph CLI 0.1.49 adds a dockerfile command to generate customized Dockerfiles for the LangGraph API server.

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

$ langgraph dockerfile --config langgraph.json --output Dockerfile

• ›New dockerfile CLI command generates a Dockerfile for the LangGraph API server, accepting a save path and configuration file for customization.
• ›Docker image generation now sets PYTHONDONTWRITEBYTECODE=1 and passes --no-cache-dir to pip installs, producing smaller images.

LangGraph SDK 0.1.26 adds batch run creation, cron job scheduling, and thread conflict handling

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

crons = await client.crons.search(assistant_id="asst-abc", limit=20, offset=0)

• ›New RunCreate TypedDict enables structured background run creation with fields for thread_id, assistant_id, input, metadata, and run configuration options.
• ›New create_batch method on LangGraphClient submits multiple runs in a single API call for more efficient batch operations.
• ›New Cron class and search method support scheduled job management, with filtering by assistant_id and thread_id and pagination.
• ›New OnConflictBehavior type ("raise" or "do_nothing") controls what happens when a thread is created that already exists, via the new if_exists parameter on Threads.create.

LangGraph 0.1.8 adds node-level metadata support via add_node's new metadata parameter and the NodeSpec class.

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

graph.add_node("my_agent", my_runnable, metadata={"team": "red-team", "criticality": "high"})

• ›Adds an optional metadata parameter to Graph.add_node to attach arbitrary metadata to graph nodes, surfaced through NodeSpec instances.
• ›Introduces langgraph.graph.graph.NodeSpec, a new class that stores a runnable alongside optional metadata for a node.
• ›Propagates node metadata through PregelNode.__init__ into the node's configuration.
• ›Exposes node metadata in graph visualizations via the updated CompiledGraph.get_graph method.

LangGraph 0.1.7 adds persistent task-write checkpointing via new put_writes/aput_writes methods, enabling resilient interrupted-workflow recovery.

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

from langgraph.checkpoint.sqlite import SqliteSaver

checkpointer = SqliteSaver.from_conn_string('checkpoints.db')

# During a custom checkpointer integration, flush task writes explicitly:
checkpointer.put_writes(config, writes, task_id)

• ›Adds put_writes and aput_writes methods to BaseCheckpointer (implemented across Memory, SQLite, and AioSQLite checkpointers) for storing task-specific writes mid-execution.
• ›Adds pending_writes field to CheckpointTuple to carry per-task write state that is restored when a checkpoint is reloaded.
• ›Tasks with pre-loaded pending_writes are skipped on restart, avoiding redundant re-execution when resuming interrupted workflows.

LangGraph 0.1.6 adds RemoveMessage support for message deletion by ID and handle_tool_errors parameter in ToolNode.

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

from langgraph.prebuilt import ToolNode

tool_node = ToolNode(tools=[my_tool], handle_tool_errors=False)

from langchain_core.messages import RemoveMessage

# Return a RemoveMessage from a node to delete the message with the given ID
def cleanup_node(state):
    return {"messages": [RemoveMessage(id="msg-abc123")]}

• ›Adds handle_tool_errors parameter (defaults to True) to ToolNode in langgraph.prebuilt.tool_node, returning a friendly error message instead of raising an exception when a tool fails, so agents can continue the conversation after tool errors.
• ›Adds support for RemoveMessage from langchain-core in langgraph.graph.message.add_messages, enabling deletion of specific messages by ID from message graphs, with validation that raises an error if the target message ID does not exist.

LangGraph CLI 0.1.48 adds --debugger-base-url to point the debugger at a custom LangGraph API URL

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

$ langgraph dev --debugger-base-url https://my-dev-server.example.com:8123

• ›Adds --debugger-base-url CLI option to specify a custom URL for the debugger to access the LangGraph API, overriding the default http://127.0.0.1:[PORT]; also sets VITE_STUDIO_LOCAL_GRAPH_URL in the debugger container when the option is used.
• ›Makes Docker base image pulls verbose during build to provide better visibility into the build process.

Letta 0.3.20 adds character limits for persona/human to /config response and fixes inner thoughts for gpt-4o models.

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

• ›Adds character limits for persona and human fields to the /config API response, giving clients the data needed to enforce input constraints.
• ›Improves inner-thought generation for gpt-4o and gpt-4o-mini models via an updated prompt format, enabling these models to produce non-None inner thoughts.

Letta 0.3.19 adds customizable memory classes via BaseMemory and unifies tools/memory in the agent creation API.

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

• ›Adds BaseMemory base class enabling developers to define custom memory fields and custom memory-editing functions beyond the built-in human/persona fields and core_memory_append/core_memory_replace tools.
• ›Adds ChatMemory as the new default memory class, preserving the original human/persona fields and core_memory_append/core_memory_replace editing functions.
• ›Extends client.create_agent() to accept memory and tools arguments, allowing custom memory classes and tool lists to be specified at agent creation time; memory-editing methods from the BaseMemory subclass are automatically registered as agent tools.
• ›Provides a migration script at scripts/migrate_0.3.18.py for upgrading agents from v0.3.18 to v0.3.19 due to AgentState schema changes.

LlamaIndex v0.10.52 adds Iceberg reader, MongoDB hybrid search, LiteLLM proxy embeddings, and async Azure AI Search methods.

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

from llama_index.embeddings.litellm import LiteLLMEmbedding

embed_model = LiteLLMEmbedding(model="text-embedding-ada-002", api_base="http://localhost:8000")

from llama_index.readers.notion import NotionPageReader

reader = NotionPageReader(integration_token="<token>")
databases = reader.list_databases()
print(databases)

• ›Adds list_databases method to llama-index-readers-notion for programmatic Notion database discovery.
• ›Adds llama-index-embeddings-litellm v0.1.0 integration supporting LiteLLM Proxy Server as an embeddings backend.
• ›Adds async methods to llama-index-vector-stores-azureaisearch for non-blocking Azure AI Search operations.
• ›Adds Hybrid Search and Full-Text Search to MongoDBAtlasVectorSearch in llama-index-vector-stores-mongodb.
• ›Adds llama-index-readers-iceberg v0.1.0 integration for reading Apache Iceberg tables into LlamaIndex.

AutoGen v0.2.32 adds Groq and Cohere client support, expanding non-OpenAI model integrations.

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

• ›Adds Groq client support, enabling AutoGen agents to use Groq-hosted models as a drop-in LLM backend.
• ›Adds Cohere client support, enabling AutoGen agents to use Cohere models as a drop-in LLM backend.
• ›Adds tool/function-call support for AnthropicClient and AnthropicAgent in the .NET SDK.

Semantic Kernel Python 1.3.0 adds a standalone chat completion agent, Ollama SDK migration, and Azure AI Inference application ID support.

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

• ›Adds application_id support for the Azure AI Inference connector.
• ›Introduces the single, non-group chat completion agent class with concept samples.
• ›Migrates the Ollama integration to the official Ollama Python SDK.
• ›Adds singular get methods to kernel collections for retrieving individual items without iterating.
• ›Improves JSON schema generation for Union and Optional type annotations in kernel functions.

Semantic Kernel 1.16.0 adds NexusRaven function calling, OpenAPI-as-plugin-description, Kernel-free OpenAPI plugin creation, and graduated Filters API.

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

var options = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };
var memoryPlugin = new TextMemoryPlugin(memory, jsonSerializerOptions: options);
kernel.ImportPluginFromObject(memoryPlugin);

• ›Enables creating a KernelPlugin from an OpenAPI spec without requiring a Kernel instance, simplifying plugin instantiation in DI and test scenarios.
• ›Uses the OpenAPI description field as the default plugin description when importing OpenAPI-based plugins.
• ›Graduates the Filters API from experimental to stable, making prompt and function invocation filters production-ready.
• ›Adds dynamic logging methods to the .NET Agents framework.
• ›Supports custom JsonSerializerOptions passed to TextMemoryPlugin for serialization control.

Semantic Kernel Python 1.2.0 adds Mistral AI chat, Azure Model-as-a-Service connector, and cross-model function calling abstraction.

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

• ›Introduces FunctionChoiceBehavior, a new function-calling abstraction that enables function calling for models beyond OpenAI (the existing FunctionCallBehavior continues to work but migration is encouraged).
• ›Adds a new Azure Model-as-a-Service connector to the Python SDK.
• ›Adds support for function calling via the Azure AI Inference connector.
• ›Adds Mistral AI Chat Completion support.

Semantic Kernel 1.15.1 adds streaming for ChatCompletionAgent, Gemini system-message support, and single-agent OpenAIAssistantAgent invocation.

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

• ›Adds cancellation token support to filter context types.
• ›Adds streaming support for ChatCompletionAgent in the Agents framework.
• ›Enables single-agent / no-chat invocation of OpenAIAssistantAgent.
• ›Supports direct logger association with an Agent.
• ›Adds Gemini support for system messages and removes message-order limitations.

camel-ai v0.1.5.5 adds Claude 3.5, Redis cache, Docker code execution, Jina Reader, and async utilities

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

• ›Adds Redis cache storage backend for agent memory and caching workflows.
• ›Supports internal_python code interpreter as a callable tool, enabling agents to execute code directly.
• ›Adds Docker-based code execution sandbox for isolated, safe code running.
• ›Integrates Jina Reader into the loaders API for web content ingestion.
• ›Adds a config file mechanism for models using the OpenAI-compatible interface.

KoboldCpp v1.70.1 adds Corpo Mode UI, DRY sampler, --unpack self-extraction, OpenAI function calling, and raises default context to 4096.

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

$ koboldcpp.exe --model mymodel.gguf --chatcompletionsadapter Llama-3.json

$ koboldcpp_oldcpu.exe --model mymodel.gguf --contextsize 4096

• ›Adds --unpack flag enabling self-extraction of KoboldCpp PyInstaller binaries into an empty directory for easy file access and modification; also usable from the GUI launcher.
• ›Adds --chatcompletionsadapter selection by bundled template filename (e.g. Llama-3.json), allowing pre-bundled chat completion templates to be referenced without a full path.
• ›Raises default --contextsize from 2048 to 4096 and increases the default Chat Completions API output length.
• ›Adds DRY dynamic N-gram anti-repetition sampler support.
• ›Adds experimental support for OpenAI tools and function calling API.

KoboldCpp v1.69.1 adds premade Chat Completions adapters, SD prompt injection fields, Vulkan tensor-split UI, and multi-image LLaVA separator tokens.

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

add_sd_prompt: "masterpiece, best quality"
add_sd_negative_prompt: "blurry, low quality, nsfw"

• ›Adds add_sd_prompt and add_sd_negative_prompt fields in a loaded adapter to inject forced positive or negative prompts for Stable Diffusion generation.
• ›Adds premade Chat Completions adapters selectable in the GUI launcher (via --chatcompletionsadapter) to apply instruct templates for various models and formats when using third-party OpenAI-compatible frontends.
• ›Adds a tensor split input field in the GUI launcher for Vulkan backends.
• ›Adds separator tokens between multiple images in LLaVA multi-image requests.
• ›Kobold Lite can now fall back to an alternative API or endpoint URL on connection failure, including retrying via the OpenAI API.

LocalAI v2.19.1 adds P2P federated AI swarms, llama.cpp embeddings, model pull by URL, and a HuggingFace /scan endpoint.

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

$ local-ai --p2p --federated

$ local-ai --p2p

• ›Adds --p2p and --p2p --federated CLI flags to launch federated LocalAI instances that auto-discover each other across networks using a shared token, with optional load balancing.
• ›Adds --p2p flag support for distributing model weights across nodes as P2P workers, currently available on the llama.cpp backend.
• ›Adds a HuggingFace /scan API endpoint for scanning HuggingFace resources.
• ›Enables embedding support in the llama-cpp (gRPC) backend via the embeddings endpoints.
• ›Adds model pulling directly from URLs via feat(models): pull models from urls.

LocalAI v2.19.0 adds P2P federated instances, llama-cpp embeddings, HuggingFace /scan endpoint, and URL-based model pulling.

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

$ local-ai --p2p --federated

• ›Adds --p2p flag to start LocalAI and generate a shared token for auto-discovering and clustering multiple instances into a load-balanced AI swarm without Docker or Kubernetes.
• ›Adds --p2p --federated flags to launch fully federated LocalAI instances that share requests across the cluster, with auto-discovery across different networks.
• ›Adds HuggingFace /scan endpoint for scanning HuggingFace model assets.
• ›Adds embeddings endpoint support to the llama-cpp (grpc) backend, enabling local embedding generation via llama.cpp.
• ›Adds load-balanced option to the P2P federation mode.

LocalAI v2.18.1 adds backend autodetect fallback and six new models to the gallery.

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

• ›Adds backend fallback with autodetection, allowing LocalAI to automatically select an available backend when the primary one is unavailable.
• ›Adds new-dawn-llama to the model gallery.
• ›Adds l3-aethora-15b-v2 to the model gallery.
• ›Adds bungo-l3-8b-iq-imatrix to the model gallery.
• ›Adds llama3-8b-darkidol-2.1-uncensored-1048k-iq-imatrix to the model gallery.

SGLang v0.1.20 enables CUDA graphs by default, adds Gemma2/MiniCPM/Qwen2 MoE support, and ships Docker images.

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

$ python -m sglang.launch_server --model-path <model> --enable-p2p-check

• ›Adds --enable-p2p-check option to the CLI for peer-to-peer connectivity validation.
• ›Exposes logprob options to the sgl.gen API via new LogitsMetadata support.
• ›Enables CUDA graph execution by default, delivering 1.5x–2x speedup for small-batch decoding.
• ›Adds model support for Gemma2, MiniCPM, and Qwen2 MoE.
• ›Adds Docker support with a new Dockerfile.

SGLang v0.1.18 adds multi-node tensor parallelism, 2x large-batch prefill throughput, ChatGLM support, and new CLI arguments.

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

$ python -m sglang.launch_server --model-path meta-llama/Llama-2-7b-chat-hf --log_level_http warning

$ python -m sglang.bench_latency --model-path meta-llama/Llama-2-7b-chat-hf

• ›Adds --log_level_http argument to control HTTP request logging independently of the main log level.
• ›Adds --dtype argument to expose model dtype selection at server launch.
• ›Adds sglang.bench_latency module for offline latency benchmarking.
• ›Enables flashinfer kernels by default, delivering a 2x throughput improvement for large-batch prefill workloads.
• ›Supports multi-node tensor parallelism, enabling model serving across multiple machines.

textgen v1.11 defaults to chat-instruct mode, adds Mistral-Nemo support, and enables gradio subpath customization for reverse proxies.

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

• ›Adds support for customizing the gradio subpath for use with a reverse proxy.
• ›Adds ChatML-format.json format example for training.
• ›Supports Mistral-Nemo via llama-cpp-python bump to 0.2.83.
• ›Defaults new sessions to chat-instruct mode, which automatically applies the model's Jinja2 template for higher-quality outputs.
• ›Significantly faster and more responsive UI through refactored event handling that reduces connections between the UI and the server.

oobabooga textgen v1.10 adds Gemma-2 support via ExLlamaV2 and new attention-disable flags.

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

• ›Adds --no_xformers and --no_sdpa flags for ExLlamaV2 (complement the existing --no_flash_attn flag); all three must be used together — or their UI checkboxes enabled — to run Gemma-2 without severe performance degradation.
• ›ExLlamaV2 updated to 0.1.7, enabling Gemma-2 model support.

oobabooga text-gen v1.9 adds 4-bit/8-bit KV cache for llama.cpp, Gemma-2 support, and a rewritten Whisper STT extension.

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

• ›Adds 4-bit and 8-bit KV cache options to llama.cpp and llamacpp_HF backends via the existing --cache_4bit and --cache_8bit flags.
• ›Adds native Gemma-2 support in Transformers: automatically detects Gemma2ForCausalLM architecture and applies optimal settings (bfloat16/float16 precision and eager attention) without requiring --bf16 --use_eager_attention manually.
• ›Automatically obtains the EOT token from Jinja2 templates and adds it to stopping strings, so Llama-3-Instruct stops correctly without manually adding <eot> to custom stopping strings.
• ›Rewrites the Whisper STT extension, replacing the Gradio microphone component with a custom microphone element for improved reliability.
• ›Increases the chat area size on mobile devices.

vLLM v0.5.2 adds a new CLI, PaliGemma/Fuyu-8B support, Medusa speculative decoding, soft-tuned prompts, and cross-Python wheels.

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

• ›New experimental vllm CLI for serving and querying an OpenAI-compatible server without writing Python.
• ›Adds support for PaliGemma and Fuyu-8B multimodal models.
• ›Adds Medusa speculative decoding with a Top-1 proposer, enabling faster inference with draft-model-free speculation.
• ›Adds soft-tuned prompt (prompt adapter) insertion support for customizing model behavior without fine-tuning weights.
• ›Releases a Python-version-agnostic wheel so a single build installs across all supported Python versions.

vLLM v0.5.1 adds pipeline parallelism, Gemma 2/Jamba/DeepSeek-V2/Phi3-Vision support, OpenVINO backend, and speculative decoding improvements.

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

$ python -m vllm.entrypoints.openai.api_server --model meta-llama/Meta-Llama-3-70B --pipeline-parallel-size 4

• ›Adds --pipeline-parallel-size flag to the API server to enable pipeline parallelism across multiple GPUs (early stage).
• ›Adds MLPSpeculator and Typical Acceptance Sampler to speculative decoding, plus a new Draft Model Runner.
• ›Adds support for sharded tensorized models via the frontend and core engine.
• ›Adds continuous streaming of OpenAI response token stats.
• ›Adds support for FlashInfer as an optional backend for prefill, decode, and CUDA Graph for decode.

Ollama v0.3.0 adds tool/function-calling support via the Chat API, plus four new models including Llama 3.1 and Mistral Large 2.

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

import ollama

response = ollama.chat(
    model='llama3.1',
    messages=[{'role': 'user', 'content': 'What is the weather in Toronto?'}],
    tools=[{
      'type': 'function',
      'function': {
        'name': 'get_current_weather',
        'description': 'Get the current weather for a city',
        'parameters': {
          'type': 'object',
          'properties': {
            'city': {
              'type': 'string',
              'description': 'The name of the city',
            },
          },
          'required': ['city'],
        },
      },
    }],
)

print(response['message']['tool_calls'])

• ›Adds tool calling support to the Chat API, enabling models to invoke functions, browse the web, run code interpreters, and interact with external APIs.
• ›Supports Llama 3.1 (8B, 70B, 405B) with native tool-calling capability.
• ›Supports Mistral Large 2 (123B) with 128k context, code generation, tool calling, math, and multilingual reasoning.
• ›Supports Firefunction v2, an open-weights function-calling model competitive with GPT-4o function calling.
• ›Supports Llama-3-Groq-Tool-Use, a series of models optimized for tool use and function calling.

Ollama v0.2.8 adds Mistral Nemo (12B, 128k context) and NuExtract (3.8B info-extraction) models, plus template validation on create.

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

$ ollama run mistral-nemo

$ ollama run nuextract

• ›Adds Mistral Nemo, a 12B model with 128k context length built by Mistral AI and NVIDIA, available via ollama run mistral-nemo.
• ›Adds NuExtract, a 3.8B Phi-3-based model fine-tuned for structured information extraction.
• ›ollama create now validates templates at creation time, catching errors before deployment.

Ollama v0.2.6 adds Mathstral, a 7B math reasoning model from Mistral AI.

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

• ›Adds Mathstral, a 7B model from Mistral AI optimized for math reasoning and scientific discovery, available via ollama pull mathstral.

Ollama v0.2.4 enables loading models larger than system memory when disk space is available.

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

• ›Supports loading models larger than system memory by spilling to disk when disk space is available.

Ollama v0.2.0 adds concurrent request handling, multi-model loading, and three new models including Gemma 2.

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

$ ollama ps

• ›New ollama ps subcommand shows which models are currently loaded, along with size, processor utilization, and expiry time.
• ›Supports serving multiple simultaneous requests in parallel using only a small amount of additional memory per request — enabling concurrent chat sessions, code completion, document processing, and multi-agent workloads.
• ›Supports loading multiple different models into GPU memory at the same time, with automatic load/unload based on request demand and available GPU memory — enabling RAG pipelines where embedding and text completion models run side-by-side.
• ›Adds GLM-4, a multilingual general-purpose model competitive with Llama 3, to the Ollama model library.
• ›Adds CodeGeeX4, a code-completion and AI software development model, to the Ollama model library.

Phoenix 4.15 adds containedInDataset GraphQL field, annotation macros, dataset edit UI, and lazy span loading.

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

• ›Adds containedInDataset boolean field to GraphQL Spans type, enabling queries that filter spans by dataset membership.
• ›Adds annotation macro and filter condition snippets to the project page UI for faster annotation workflows.
• ›Adds dataset edit UI and support for supplying dataset metadata at creation time.
• ›Adds version mismatch checks to warn when client and server versions differ.
• ›Implements lazy loading of spans in the trace UI, enabling performant rendering of large traces.

Phoenix v4.14.0 adds an annotations UI and extends the evals DSL with an annotations symbol.

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

• ›Extends the evals DSL to accept the annotations symbol, enabling annotation data to be referenced directly in evaluation expressions.
• ›Adds a new annotations UI for viewing and managing span/trace annotations.

Phoenix v4.13.0 adds a GraphQL resolver to query all annotation names on a project.

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

• ›Adds a GraphQL resolver that returns all annotation names on a project, enabling programmatic discovery of annotation surfaces.

Arize Phoenix 4.12.0 adds timeout arguments to client methods.

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

• ›Adds timeout arguments to client methods, enabling callers to control request duration limits.

Phoenix v4.11.0 adds a Guardrail span kind and a GraphQL resolver for span annotations.

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

• ›Adds GraphQL resolver for querying annotations on a span, enabling programmatic retrieval of span-level annotation data.
• ›Adds GUARDRAIL span kind type, extending the span taxonomy to cover guardrail components in LLM pipelines.

Phoenix v4.10.0 adds GraphQL mutations and REST routes for span and trace annotations, plus UI copy of IDs.

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

• ›Adds REST routes for span and trace annotations, enabling programmatic annotation of spans and traces via HTTP.
• ›Adds GraphQL mutations for span and trace annotations, exposing annotation operations over the GQL API.
• ›Adds UI ability to copy span and trace IDs directly from the annotations interface.

Phoenix 4.8.0 adds a REST endpoint to delete datasets from experiments.

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

• ›Adds a REST endpoint to delete a dataset in the experiments API.

Phoenix v4.7.0 adds image rendering for messages in the UI.

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

• ›Renders images inline within messages in the trace/span UI.

Phoenix v4.6.0 ships datasets, experiments, and LLM evaluators with new client methods, GraphQL resolvers, and environment-variable auth headers.

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

import phoenix as px
from phoenix.evals import create_evaluator

@create_evaluator
def my_evaluator(output, expected):
    return output.strip() == expected.strip()

import phoenix as px
from phoenix.evals import create_evaluator

@create_evaluator
def exact_match(output, reference):  # 'reference' is an alias for 'expected'
    return output.strip() == reference.strip()

• ›Adds reference as an alias for expected in evaluator argument bindings via **datasets** evaluator function signatures.
• ›Adds get_dataset_by_name client method to retrieve datasets by name.
• ›Adds a client method for appending to existing datasets.
• ›Adds create_evaluator decorator for defining custom evaluators.
• ›Adds built-in LLM evaluators and a relevance evaluator for experiment outputs.

Langfuse v2.66.0 adds version/release trace filters, promptName/promptVersion on observations, Redis API key and prompt caching, and configurable JWT session duration.

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

$ curl -X GET 'https://<your-langfuse-host>/api/public/traces?version=1.2.0&release=prod' \
  -H 'Authorization: Bearer <secret-key>'

$ AUTH_SESSION_MAX_AGE=3600

• ›Adds version and release query filters to the GET /traces and GET /observations API routes, enabling precise retrieval of traces and observations by deployment version or release.
• ›Adds promptName and promptVersion fields to observations returned by the API, exposing which prompt and version drove each LLM call.
• ›Adds AUTH_SESSION_MAX_AGE environment variable to customize JWT session duration, with a 5-minute polling interval.
• ›Adds server-side Redis caching for API keys and prompts, reducing database load on high-throughput deployments.
• ›Adds a connection-check endpoint for ClickHouse to verify infrastructure health.

Langfuse v2.65.0 adds image rendering in markdown, datetime filters, and gpt-4o mini support in playground and evals.

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

• ›Adds gpt-4o mini as a supported model in the playground and evals.
• ›Extends date filters to full datetime precision across the UI.
• ›Renders inline images in markdown view when a markdown image URL is provided.

Langfuse v2.64.0 adds a new REQUESTS billing unit, gpt-4o-mini model support, and improved long-string display in the UI.

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

• ›Adds REQUESTS as a new unit type for model cost tracking, enabling per-request pricing models.
• ›Adds built-in support for the gpt-4o-mini model.
• ›Long strings in the trace UI now collapse with an '... expand' control and preserve whitespace when expanded.

Langfuse v2.63.0 adds a UI toggle to enable or disable markdown rendering in pretty format view.

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

• ›Adds a button in the UI to enable or disable markdown rendering when the pretty format is selected for trace/observation output.

Langfuse v2.62.0 adds markdown rendering on the Trace page and expands full string display in table rows.

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

• ›Adds markdown rendering for content displayed on the Trace page in the UI.

Langfuse v2.61.0 adds a GET /sessions endpoint and expands time-based filters across existing GET APIs.

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

• ›Adds GET /sessions API endpoint for retrieving session data programmatically.
• ›Adds additional time-based filters to existing GET APIs for more precise querying.
• ›Defaults the dashboard date range to 1 day for faster initial load performance.

Langfuse v2.60.0 adds non-numeric score support via API and new 5-minute/3-hour dashboard timeframes.

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

• ›Adds support for non-numeric scores and score configs via the API, dropping the non-null constraint on the value field in the scores table — enabling categorical/qualitative scoring alongside numeric scores.
• ›Adds 5-minute and 3-hour timeframe options to the dashboard for finer-grained monitoring windows.

Langfuse v2.59.1 adds AWS Bedrock Anthropic model name support and formatted token number display.

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

• ›Adds AWS Bedrock model names for Anthropic models, enabling accurate token and cost tracking for Bedrock-hosted Anthropic usage.
• ›Token counts in the UI are now formatted for readability (e.g., large numbers displayed with separators).

Langfuse v2.59.0 adds a models API route and expand/collapse controls for the trace timeline.

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

• ›Adds models API routes, enabling programmatic management of model definitions.
• ›Adds expand/collapse all buttons to the trace timeline UI for faster navigation of complex traces.
• ›Fetches metadata individually on generations and traces tables, improving UI performance for large datasets.

Langfuse v2.58.0 adds ARM64 Docker builds, datasets v2 API, custom OAuth scopes, and manual Postgres migration control.

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

• ›Adds AUTH_CUSTOM_SCOPE environment variable to override the OAuth scopes used in custom OAuth provider setups.
• ›Adds LANGFUSE_AUTO_POSTGRES_MIGRATION_DISABLED environment variable to disable automatic Postgres migrations on startup, enabling manual migration control.
• ›Introduces datasets v2 API with a new typed public API interface.
• ›Publishes official Docker images for the arm64 architecture.
• ›Auto-selects the first operator in the filter builder UI, reducing clicks when constructing filters.

Weave v0.50.11 adds LangChain integration, CallsIter caching/slicing, threading helpers, and URL-persisted pagination state.

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

• ›Adds caching and slicing support for CallsIter, enabling more efficient iteration over large call collections.
• ›Adds threading helpers via feat(weave) to simplify concurrent thread usage in Weave workflows.
• ›Adds LangChain integration, enabling tracing and evaluation of LangChain-based applications with Weave.
• ›Updated column management dialog improves control over visible columns in the trace table UI.
• ›Stores pagination state in the URL, so table pagination position is preserved and shareable across sessions.

Weave v0.50.10 adds Cohere and Groq autopatch integrations, bulk deletion mode, and URL-persistent call grid sorting.

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

• ›Adds autopatch integration with Groq, enabling automatic tracing of Groq chat calls.
• ›Adds Cohere chat models integration for automatic tracing of Cohere calls.
• ›Introduces bulk deletion mode in the UI for removing multiple calls at once.
• ›Stores the calls grid sort state in the URL, making sorted views shareable and persistent across sessions.
• ›Improves ergonomics for interacting with private Weave instances.

Weave v0.50.8 adds DSPy integration, a new column management popup, and an updated OpenAI integration design pattern.

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

• ›Adds new DSPy integration, enabling tracing and observability for DSPy-based LLM pipelines.
• ›Introduces a new column management popup in the UI for controlling visible columns in trace/eval tables.
• ›Updates the OpenAI integration to adhere to a new design pattern, aligning it with the broader integration architecture.
• ›Adds a rename button to the overflow menu for objects in the UI.

Weave v0.50.7 adds a Use tab to call details and renders Anthropic input images as thumbnails in the UI.

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

• ›Adds a 'Use' tab to call details for quick reference on how to access or replay a call.
• ›Renders Anthropic input images as thumbnails in the call detail view.

Weave v0.50.6 adds call feedback UI, a new .call() method on ops, and promotes get_current_call to a top-level API.

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

import weave

@weave.op()
def my_llm_call(prompt: str) -> str:
    return "response"

result, call = my_llm_call.call("What is the capital of France?")
print(call.id)

import weave

@weave.op()
def process(data: str) -> str:
    current = weave.get_current_call()
    print(current.id)
    return data

• ›Adds call function to decorated ops, returning a Call object alongside the op's result — accessible as my_op.call(...).
• ›Promotes get_current_call to a top-level API, making the active call inspectable from anywhere without internal imports.
• ›Adds a feedback tab to the call details page in the UI, surfacing notes and emoji reactions per call.
• ›Adds UI to attach notes and emoji reactions to individual calls.
• ›Adds basic call renaming in the UI.

LanceDB v0.8.0 adds reciprocal rank fusion reranking, HuggingFace-compatible transformers for Node.js, and upgrades Lance to 0.15.0

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

• ›Adds a reciprocal rank fusion (RRF) reranker for combining hybrid search result rankings.
• ›Adds HuggingFace-compatible transformers embedding support in the Node.js SDK.
• ›Upgrades the underlying Lance storage engine to v0.15.0.

LanceDB python-v0.10.2 adds native HuggingFace sentence-transformers embedding support via Rust.

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

• ›Adds HuggingFace sentence-transformers as a natively supported embedding provider via the Rust backend.

LanceDB v0.7.2 adds Hugging Face sentence-transformers embedding support for the Rust SDK.

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

• ›Adds Hugging Face sentence-transformers embedding integration to the Rust SDK.

LanceDB v0.7.1 adds configurable timeout support to the VectorDB Node SDK.

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

• ›Adds configurable timeout support to the VectorDB Node SDK.

LanceDB python-v0.10.0 adds DynamoDB commit store, Jina embeddings/reranking, explain_plan, fast search, and binary field updates.

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

from lancedb.embeddings import get_registry
from lancedb.rerankers import JinaReranker

jina_embed = get_registry().get('jina').create()
reranker = JinaReranker()

results = table.search('cybersecurity threat intelligence') \
    .rerank(reranker=reranker) \
    .to_pandas()

• ›Adds explain_plan function to inspect query execution plans.
• ›Adds fast search flag support in Rust-backed queries.
• ›Enables DynamoDB as a commit store backend for distributed coordination.
• ›Adds Jina integration for both embedding generation and reranking in Python.
• ›Supports creating additional vector index types beyond the previous set.

LanceDB v0.7.0 adds DynamoDB commit store, Jina embeddings/reranking, new vector index types, and explain_plan for query inspection.

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

$ await tbl.update({ valuesSql: { price: 'price * 1.1' } })

• ›Adds update({values | valuesSql}) to the Node.js table API, enabling row updates via value maps or raw SQL expressions.
• ›Adds explain_plan function for inspecting query execution plans.
• ›Makes tbl.search() chainable in the Node.js client.
• ›Adds DynamoDB commit store support for distributed, cloud-backed transaction coordination.
• ›Adds Jina integration in Python for both embedding generation and reranking.

Weaviate v1.26.0 adds tenant offloading to S3, multi-target vector search, scalar quantization, async replication, and improved range filters.

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

{
  "class": "Product",
  "properties": [
    {
      "name": "price",
      "dataType": ["number"],
      "indexRangeFilters": true
    }
  ]
}

{
  Get {
    Article(
      nearText: {
        concepts: ["climate change"],
        targets: { combinationMethod: minimum, targetVectors: ["title", "body"] }
      }
    ) {
      title
      body
    }
  }
}

• ›Adds OFFLOAD_S3_ENDPOINT environment variable (renamed from S3_ENDPOINT_URL) to configure S3-compatible object storage for tenant offloading.
• ›Adds FROZEN tenant status via REST and gRPC APIs, enabling inactive tenant data to be offloaded to S3-compatible object storage to reduce compute costs.
• ›Adds IndexRangeFilters property config to enable a new roaring-set range index, drastically improving performance of numeric range queries at scale.
• ›Adds a reindex endpoint to the REST API.
• ›Adds Scalar Quantization (SQ) vector compression, mapping floating-point vector values to integers to reduce storage size while maintaining search accuracy.

Weaviate v1.25.8 adds opt-in Sentry error reporting and a new flag to force full-replica shard searches.

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

• ›Adds a new flag to force search to query all replicas of a shard when possible, improving search completeness in replicated deployments.
• ›Integrates Sentry error reporting (opt-in, disabled by default) with automatic reporting of vector search failures and shard initialization errors.

Composio v0.3.28 adds a JavaScript SWE (Software Engineering) agent example and accompanying JS SWE documentation.

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

• ›Adds a JavaScript SWE (Software Engineering) agent example, expanding Composio's agentic workflow support to JS environments.

Composio v0.3.26 adds COMPOSIO_BASE_URL config, JS SDK workspace support, and an in-memory file manager.

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

• ›Adds COMPOSIO_BASE_URL environment variable to configure the base URL for the Composio service.
• ›Adds workspace support to the JavaScript SDK.
• ›Adds an in-memory file manager.
• ›Passes OAuth scope through the authorization flow.
• ›Adds a CLI release flow.

Composio v0.3.24 adds OAuth scope selection when adding connections and automatic GitHub token retrieval for agent workspaces.

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

• ›Adds support for specifying OAuth scopes when adding a connection via composio add.
• ›Reads GitHub access token automatically from the Composio account for agent workspaces, removing the need to supply it manually.
• ›Switches Docker-based agent workspaces to use the tooling server.

Composio v0.3.21 adds LangGraph plugin, FlyIO workspace, paramiko shell sessions, code indexing, and new toolset methods.

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

• ›Adds get_agent_instruction method to the toolset for retrieving agent instructions directly from tool configurations.
• ›Adds file_uploadable option to support file upload capabilities in tool definitions.
• ›Adds 'Add integration by id' function for retrieving integrations by their identifier.
• ›Introduces a LangGraph plugin, enabling Composio tool use within LangGraph agent workflows.
• ›Integrates paramiko for interactive shell sessions, enabling SSH-based interactive execution environments.

Composio v0.3.19 adds an @action decorator for custom actions and a new Spider scraper & crawler tool integration.

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

• ›Adds @action decorator (importable at top level) to define custom actions directly in Python code.
• ›Adds Spider scraper and crawler tool integration for web scraping and crawling workflows.
• ›Ports Docker utilities to swekit for software-engineering kit workflows.

Composio v0.3.17 adds Camel-AI plugin, Cloudflare AI integration, Zep tool, multi-workspace support, and shell exit code reading.

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

• ›Adds $COMPOSIO_DEV_MODE environment variable for development mode configuration.
• ›Adds composio-camel plugin, integrating Composio with the Camel-AI framework.
• ›Adds Cloudflare AI as a supported integration.
• ›Adds zep as a supported tool within Composio.
• ›Adds a composio-core package for core library functionality.