The AI Toolchain — issue -372, November 30, 2024

Aider v0.64.0 adds /editor command, multiline input tags, global extra_params, and GPT-4o/o1 streaming support.

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

$ aider --show-release-notes=false <file>

# In ~/.aider.model.settings.yml
- name: aider/extra_params
  extra_params:
    temperature: 0.2
    max_tokens: 4096

• ›Adds /editor command to open the system editor for composing prompts without leaving the chat.
• ›Adds support for optional multiline input tags with matching closing tags for structured multi-line chat messages.
• ›Adds --show-release-notes flag to control whether release notes are displayed on first run of a new version.
• ›Supports global extra_params in model settings configuration, passed directly to litellm.completion().
• ›Architect mode now automatically prompts to add files suggested by the LLM.

Aider v0.63.0 adds Qwen 2.5 Coder 32B support and a quieter /web command that appends pages without triggering LLM responses.

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

$ /web https://example.com/api-reference

• ›Supports Qwen 2.5 Coder 32B as a model option.
• ›The /web command now adds a page to the chat context silently, without triggering an LLM response.
• ›Improved prompting for the user's preferred chat language.

Aider v0.62.0 adds Claude 3.5 Haiku support and a new --apply-clipboard-edits flag to apply LLM edits from web apps.

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

$ aider --haiku

$ aider --apply-clipboard-edits file-to-edit.js

• ›Adds --haiku flag to launch Aider using Claude 3.5 Haiku (75% on the code editing leaderboard, lower cost than Sonnet).
• ›New --apply-clipboard-edits flag applies file changes copied from ChatGPT, Claude, or other web app LLM responses directly to local files.

Aider v0.61.0 adds saveable chat context files, opt-in analytics, and new launch/input flags.

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

$ aider> /save context.aider
# later or in another session:
aider> /load context.aider

$ aider --load project_context.aider --model gpt-4o

$ aider --no-fancy-input

• ›New /save <fname> command exports current chat file context as a replayable file of /add and /read-only commands.
• ›New /load <fname> command replays any set of slash-commands from a file, enabling scripted chat workflows.
• ›New --load <fname> flag runs a command file at launch, before interactive chat begins.
• ›Adds anonymous, opt-in analytics with no personal data sharing.
• ›Enables image support for models dynamically by following litellm's supports_vision attribute.

OpenHands 0.14.1 adds a push-to-GitHub button directly in the chat interface.

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

• ›Adds a 'Push to GitHub' action button in the chat interface for pushing changes directly from a session.

OpenHands 0.14.0 adds an embedded VSCode editor, GitHub issue resolver integration, and universal function-calling shim for non-native LLMs.

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

• ›Adds a full VSCode editor directly inside the OpenHands runtime and UI, giving agents and users an integrated code editing experience.
• ›Integrates the OpenHands resolver into the main repository, enabling automated GitHub issue resolution workflows natively.
• ›Adds a utility that automatically converts function-calling LLM requests to non-function-calling format, broadening compatible model support.

OpenHands 0.13.1 adds workspace media previews and improved GitHub push support.

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

• ›Supports displaying images, videos, and PDFs directly in the workspace UI.
• ›Improves pushing changes to GitHub from within a session.

OpenHands 0.13.0 adds drag-and-drop image input to chat and a loading indicator for ZIP downloads.

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

• ›Supports dragging images directly into the chat input for multimodal interactions.
• ›Shows a loading indicator when downloading a workspace ZIP file.
• ›New empty-state design for the chat interface.

OpenHands 0.12.2 gives CodeAct native web browsing, adds PostHog analytics, and integrates DiscoveryBench.

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

• ›Adds PostHog analytics integration for tracking usage and agent behavior.
• ›Enables CodeAct agent to perform web browsing natively — no longer delegates to a separate BrowsingAgent.
• ›Adds DiscoveryBench integration for benchmarking OpenHands agents on data-discovery tasks.

Zed v0.162.3 adds REPL kernel picker, inline-completion scope controls, FreeBSD support, and a new project_panel::RemoveFromProject action.

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

{"languages": {"Go": {"inline_completions_disabled_in": ["comment", "string"]}}}

{"lsp": {"tailwindcss-language-server": {"settings": {"rootFontSize": 20}}}}

• ›Adds inline_completions_disabled_in to per-language settings to suppress inline completions inside named scopes (e.g. comment, string) — example: {"languages": {"Go": {"inline_completions_disabled_in": ["comment", "string"]}}}.
• ›Adds rootFontSize configuration key for tailwindcss-language-server via lsp settings — example: {"lsp": {"tailwindcss-language-server": {"settings": {"rootFontSize": 50}}}}.
• ›Adds project_panel::RemoveFromProject action, enabling users to bind a custom key to remove a folder from the project.
• ›REPL: Adds a kernel picker UI for selecting Jupyter kernels directly from the editor.
• ›Adds support for kernelspecs based on Python virtual environments in the REPL.

Zed v0.161.1 adds new task-spawning actions, auto_indent_on_paste setting, git worktree support, and expanded Vim mode capabilities.

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

{
  "context": "EmptyPane || SharedScreen || vim_mode == normal",
  "bindings": {
    ", r t": ["editor::SpawnNearestTask", { "reveal": "no_focus" }]
  }
}

{
  "context": "Editor",
  "bindings": {
    "ctrl-/": ["editor::ToggleComments", { "ignore_indent": true }]
  }
}

• ›Adds auto_indent_on_paste setting (configurable per-language) to control whether indentation is adjusted on paste; enabled by default for all languages except YAML and Markdown.
• ›Adds "no_focus" as a new reveal option for tasks: opens the terminal panel without stealing focus.
• ›Adds editor::SpawnNearestTask action to spawn the task nearest to the cursor, supporting a reveal strategy parameter.
• ›Adds ignore_indent parameter to editor::ToggleComments to place comment characters at the left margin instead of matching indentation.
• ›Adds debug: Open Key Context View action to the command palette to help debug custom key bindings.

Zed v0.160.7 adds SSH URL support, new Copilot models, invisible characters display, and a 'Suggest Edit' AI button.

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

{
  "assistant": {
    "enable_experimental_live_diffs": true
  }
}

• ›Adds zed://ssh/<connection>/<path> URL scheme for opening remote files directly via SSH.
• ›Adds "enable_experimental_live_diffs": true in the "assistant" section of settings.json to surface a new 'Suggest Edit' button in the assistant panel, replacing the previous /workflow command.
• ›The /diagnostics slash command now provides explicit control over including diagnostics as context in the Assistant Panel (diagnostics are no longer auto-attached to /tab and /file commands).
• ›Adds support for OpenAI o1-mini, o1-preview, and Anthropic Claude 3.5 Sonnet models in GitHub Copilot Chat.
• ›Adds support for showing invisible characters in the editor.

AutoGPT Platform v0.3.2 adds Open Router integration with expanded model selection and typed JSON parsing support.

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

• ›Adds Open Router integration block, giving agents access to a large selection of new models via the Open Router service.
• ›Enables JSON parsing with typing and type conversion support in the backend, allowing blocks to handle strongly-typed JSON data.

AutoGPT Platform v0.3.1 adds Agent Execution Block, scheduling, AI image/music generation, and multi-language YouTube support.

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

• ›Adds AIImageGeneratorBlock — a unified block for generating images via multiple AI models inside AutoGPT workflows.
• ›Introduces the Agent Execution Block, enabling agents to be used as composable blocks within other agents for modular, complex pipeline construction.
• ›Introduces Scheduling Agent Runner, letting users schedule agents to run at specific times and monitor them from a dedicated monitor page in the UI.
• ›Adds the AI Music Generator Block powered by Meta Music Gen, enabling audio generation directly within workflows.
• ›Expands the YouTube Video Block to support additional languages beyond the previous default.

AutoGPT Platform v0.2.2 adds Pinecone integration blocks and an API key database table.

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

• ›Introduces a dedicated API key database table for managing credential storage.
• ›Adds Pinecone integration blocks, enabling vector database operations within AutoGPT workflows.
• ›Adds default credentials support for Jina blocks, simplifying Jina AI service configuration.

AutoGPT Platform v0.2.1 adds secret detection in pre-commit hooks and UI error toasts for graph creation failures.

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

• ›Adds secret detection to pre-commit hooks to catch leaked credentials before they reach the repository.
• ›Adds toast notifications for graph creation errors in the build page UI, surfacing failures inline instead of silently.
• ›Reduces the number of services required to run local mode, simplifying self-hosted deployments.

CrewAI 0.79.0 adds flow inputs, IBM Watson memory integration, and broader log storage data type support.

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

from crewai import BaseTool

class MyScanner(BaseTool):
    name: str = "Port Scanner"
    description: str = "Scans open ports on a given host."

    def _run(self, host: str) -> str:
        # tool logic here
        return f"Scanning {host}"

• ›Adds inputs parameter support to flows, enabling dynamic data to be passed into flow execution.
• ›Enhances log storage to support a wider range of data types beyond strings.
• ›Moves BaseTool to the main package and centralizes tool description generation, simplifying custom tool authoring.
• ›Raises an explicit error when an LLM returns no response, making silent failures visible.

DSPy 2.5.40 lets ReAct tools wrap class methods and serializes datetimes/enums via pydantic adapters.

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

import dspy

class MySearch:
    def __init__(self, index):
        self.index = index

    def search(self, query: str) -> str:
        """Search the index for a query."""
        return self.index.get(query, 'not found')

searcher = MySearch(index={'dspy': 'A framework for programming LMs'})
tool = dspy.react.Tool(searcher.search)

react = dspy.ReAct('question -> answer', tools=[tool])
print(react(question='What is dspy?'))

• ›Allows react.Tool to wrap class methods (not just standalone functions), expanding the surfaces that can be registered as ReAct tools.
• ›Adapters now support JSON serialization of arbitrary pydantic-compatible types — including datetimes, enums, and other complex types — via pydantic's serialization layer.
• ›Switches DSPy settings storage from a contextvar to thread-local storage, improving compatibility with Colab and multi-threaded environments.

DSPy 2.5.36 converts settings to a ContextVar and allows user-launched threads to inherit DSPy context safely.

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

• ›Converts dspy.settings to a ContextVar, enabling per-thread/per-context isolation of DSPy configuration.
• ›Extends ParallelExecutor to isolate context even when running with a single thread.
• ›Permits user-launched threads to carry DSPy settings context, enabling safe concurrent use outside of DSPy-managed execution.

DSPy 2.5.35 raises the default cache limit to 30 GB.

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

• ›Expands the default cache limit from its previous size to 30 GB, enabling larger-scale LM call caching without manual configuration.

DSPy 2.5.34 adds a thread-safe faiss kNN retriever, a grounded completeness metric, and an Unbatchify utility.

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

• ›Adds dspy.retrievers.Embeddings — a thread-safe, memory-friendly faiss k-nearest-neighbour retrieval index.
• ›Introduces CompleteAndGrounded metric for evaluating whether generated outputs are both complete and grounded in source context.
• ›Introduces Unbatchify utility for converting batched outputs back into individual items.

DSPy 2.5.33 adds a teacher module to MIPROv2 and improves its logging.

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

• ›Adds a teacher module to MIPROv2, enabling separate teacher-student optimization configurations.
• ›Improves MIPROv2 logging output for better visibility into optimization runs.

DSPy 2.5.30 adds dspy.asyncify for async module wrapping and native parallel execution support.

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

import dspy

predict = dspy.Predict('question -> answer')
async_predict = dspy.asyncify(predict)

result = await async_predict(question='What is the capital of France?')

• ›Adds dspy.asyncify to wrap synchronous DSPy modules for asynchronous execution.
• ›Adds native parallel execution support via ParallelExecutor for running DSPy programs concurrently.

DSPy 2.5.29 adds a Databricks finetuning integration.

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

• ›Adds Databricks finetuning integration, enabling DSPy programs to leverage Databricks-hosted model finetuning workflows.

DSPy 2.5.28 revamps BootstrapFinetune, merges BetterTogether optimizer, and adds a flag to suppress LiteLLM logs in dspy.LM.

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

• ›Adds a flag to dspy.LM to suppress LiteLLM log output, reducing noise when running DSPy programs.
• ›Revamps BootstrapFinetune and promotes the BetterTogether optimizer from experimental to main, making combined few-shot and fine-tuning optimization available in the standard release.

DSPy 2.5.26 adds exponential backoff retries for LM calls and drops the structlog dependency.

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

• ›Removes the structlog dependency, reducing the library's install footprint.
• ›Adds automatic retry with exponential backoff for LM calls on a limited set of error codes.

DSPy 2.5.23 adds image support and chainable loading for Predict modules.

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

• ›Adds chainable loading for Predict modules, enabling fluent module initialization patterns.
• ›Adds image support to DSPy programs.

langchain-ollama 0.2.2rc1 adds Ollama 0.4 support, token-level streaming with bound tools, and kwargs passthrough in requests.

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

• ›Supports Ollama 0.4 in langchain-ollama.
• ›Enables token-level streaming when using bind_tools with ChatOllama, allowing real-time output during tool-augmented calls.
• ›Passes additional kwargs through to Ollama API requests, giving callers direct control over request parameters.

langchain-community 0.3.8 adds Outlines, Reka, and SambaNova integrations plus SambaNova tool calling and structured output.

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

• ›New Outlines integration adds the Outlines LLM/model backend to langchain-community for structured text generation.
• ›New Reka chat model integration adds reka as a supported chat model provider.
• ›New SambaNova Cloud LLM integration adds sambanovacloud as a supported LLM backend.
• ›Adds tool calling and structured output support to the SambaNova Cloud integration.
• ›Adds deprecation warning for the GigaChat integration in langchain-community, signaling future removal.

langchain-core 0.3.20 adds final AIMessage support in tool_example_to_messages and expands sys_info with LangGraph packages.

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

• ›Adds support for final AIMessage responses in tool_example_to_messages, enabling tool-use examples that include a concluding assistant message.
• ›Adds other LangGraph packages to sys_info output for more complete environment diagnostics.

langchain-core 0.3.18 adds DeleteResponse to the module and a new xAI chat integration.

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

• ›Adds DeleteResponse to the langchain-core module.
• ›Adds xAI chat integration via the partners package.

langchain-anthropic 0.3.0 adds Python 3.13 support and migrates token counting to Anthropic's beta messages API.

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

from langchain_anthropic import ChatAnthropic
from langchain_core.messages import HumanMessage

llm = ChatAnthropic(model='claude-3-5-sonnet-20241022')
tools = [my_tool]
token_count = llm.get_num_tokens_from_messages(
    [HumanMessage(content='What is the weather in Paris?')],
    tools=tools
)
print(token_count)

• ›Adds ChatAnthropic.get_num_tokens_from_messages backed by the client.beta.messages.count_tokens() API, replacing the removed client.count_tokens method.
• ›Adds an optional tools parameter to ChatAnthropic.get_num_tokens_from_messages to include tool definitions in token counts.
• ›Supports Python 3.13.

langchain-core 0.3.17 adds optional tools parameter to BaseLanguageModel.get_num_tokens_from_messages

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

model.get_num_tokens_from_messages(messages, tools=tools)

• ›Adds tools as an optional parameter to BaseLanguageModel.get_num_tokens_from_messages, enabling token counting that accounts for tool definitions passed alongside messages.

langchain-community 0.3.6 adds Google Books API tool, Cloudflare Workers AI chat model, ZeroxPDF loader, Memcached LLM cache, and more new integrations.

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

• ›Adds bytes as a valid source input to AzureAIDocumentIntelligenceLoader, enabling in-memory document processing without writing to disk.
• ›Adds ZeroxPDFLoader for PDF loading via the Zerox engine.
• ›Adds ChatModels wrapper for Cloudflare Workers AI, enabling LLM inference through Cloudflare's edge AI platform.
• ›Adds Memcached LLM cache integration for distributed caching of LLM responses.
• ›Adds InfinityRerank reranker integration.

langchain-core 0.3.16 adds file_type option to mermaid graph output and friendlier duplicate-node names.

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

• ›Adds file_type option to mermaid graph rendering, defaulting to png.
• ›Uses friendlier names for duplicated nodes in mermaid diagram output.
• ›Makes OpenAI tool description optional.

LangChain Community 0.3.5 adds AzureOpenAIWhisperParser and batch embedding support for text-embedding-v3.

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

• ›Adds AzureOpenAIWhisperParser for transcribing audio via Azure OpenAI's Whisper model.
• ›Adds batch request support for the text-embedding-v3 model, enabling higher-throughput embedding workflows.
• ›Updates the Polygon.io API integration with the latest API changes.

langgraph-checkpoint-postgres 2.0.5 adds pgvector-powered semantic search to PostgreSQL-backed LangGraph stores.

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

• ›Adds PostgresIndexConfig class to configure pgvector-backed vector search with configurable dimensions, distance metrics (l2, inner_product, cosine), and vector types (vector, halfvec).
• ›Enables vector similarity search and embedding-based document indexing and retrieval in BasePostgresStore.
• ›Adds async embedding and vector search support to AsyncPostgresStore for non-blocking document indexing and retrieval.
• ›Introduces _row_to_search_item to surface similarity scores as float values alongside search results.

LangGraph CLI 0.1.60 adds vector store configuration with embedding specs, enabling semantic search in LangGraph projects.

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

from langgraph_cli.config import IndexConfig, StoreConfig

store = StoreConfig(
    index=IndexConfig(
        dims=1536,
        embed="openai:text-embedding-3-small",
        fields=["text", "description"],
    )
)

• ›Adds IndexConfig and StoreConfig configuration types to specify vector embedding dimensions (dims), model selection (embed), and custom field extraction (fields) for semantic search.
• ›Enables the dev command to pass store configuration from config.json to the LangGraph server at runtime.
• ›Supports store settings in Docker container deployments via environment variable pass-through.
• ›Adds python-dotenv as an optional dependency for environment variable management.

LangGraph SDK 0.1.40 adds natural language search to the store with relevance scoring and fine-grained index control.

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

results = await client.store.search_items(namespace, query="latest customer complaints about billing")
for item in results.items:
    print(item.score, item.key, item.value)

await client.store.put_item(namespace, key="user-42", value={"name": "Alice", "notes": "VIP customer", "internal_id": 99}, index=["name", "notes"])

await client.store.put_item(namespace, key="secret-config", value={"api_key": "s3cr3t"}, index=False)

• ›Adds query parameter to search_items (sync and async) enabling natural language search over stored items.
• ›Introduces SearchItem class extending Item with an optional score field, so callers can rank results by relevance.
• ›Updates SearchItemsResponse to return list[SearchItem] instead of list[Item], surfacing relevance scores in all search results.
• ›Adds index parameter to put_item (sync and async) to control per-item indexing: None for default, False to skip indexing, or a list[str] of field paths to index selectively.

LangGraph checkpoint 2.0.7 adds vector/semantic search to stores, richer query filters, and embedding utilities.

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

from langgraph.store.memory import InMemoryStore
from langgraph.store.base import IndexConfig
from langchain_openai import OpenAIEmbeddings

store = InMemoryStore(
    index=IndexConfig(
        dims=1536,
        embed=OpenAIEmbeddings(model="text-embedding-3-small"),
        fields=["text", "summary"],
    )
)

# Store an item (indexed by default)
await store.aput(("users", "alice"), "mem-1", {"text": "Alice prefers dark mode."})

# Retrieve semantically similar items
results = await store.asearch(("users", "alice"), query="UI preferences", limit=5)
for item in results:
    print(item.key, item.score, item.value)

from langgraph.store.base.embed import ensure_embeddings
import numpy as np

def my_embed(texts: list[str]) -> list[list[float]]:
    # Replace with your local model call
    return [np.random.rand(768).tolist() for _ in texts]

embeddings = ensure_embeddings(my_embed)

from langgraph.store.base import IndexConfig
config = IndexConfig(dims=768, embed=embeddings)

results = await store.asearch(
    ("projects", "sec-team"),
    query="privilege escalation techniques",
    filter={"severity": {"$gt": 7}, "status": {"$eq": "open"}},
    limit=10,
)
for item in results:
    print(item.key, item.score, item.value["severity"])

• ›Adds semantic similarity search to BaseStore via an updated search/asearch interface that returns ranked SearchItem instances with a score field.
• ›Introduces IndexConfig class to configure vector search settings — embedding dimensions, embedding function, and which fields to index — per store.
• ›Adds index parameter to put/aput (and PutOp) to control per-item vector indexing: use default indexing, disable with False, or specify custom field paths.
• ›Adds query parameter to SearchOp for natural-language semantic search alongside existing namespace/filter queries.
• ›Enhances query filtering in SearchOp with comparison operators ($eq, $gt, $lt, and others) including support for nested fields and array path expressions.

langgraph-checkpoint-postgres 2.0.4 adds connection pooling, pipeline optimization, and last-write-wins deduplication for Postgres stores.

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

• ›New PoolConfig TypedDict in langgraph.store.postgres.base lets you configure min/max connections and extra connection parameters for PostgreSQL connection pools.
• ›Adds connection pooling support to both PostgresStore and AsyncPostgresStore for improved throughput under high concurrency.
• ›Adds pipelined database operations to PostgresStore and AsyncPostgresStore, batching queries for higher throughput.
• ›Adds last-write-wins deduplication semantics for concurrent operations on the same key in PostgresStore.
• ›Adds thread locking (PostgresStore) and async locks (AsyncPostgresStore) for safe concurrent access.

LangGraph checkpoint 2.0.6 adds async namespace listing and batch operation deduplication to AsyncBatchedBaseStore.

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

namespaces = await store.alist_namespaces(prefix=("user", "alice"), depth=3, limit=50)

• ›Adds alist_namespaces method to AsyncBatchedBaseStore for querying namespaces with filtering by prefix, suffix, depth, and pagination.
• ›Improves batch performance in AsyncBatchedBaseStore via a new _dedupe_ops function that deduplicates identical get/search operations and consolidates multiple puts to the same key.
• ›Extends CheckpointMetadata.source to accept "fork" as a valid value, identifying checkpoints created as copies of other checkpoints.

LangGraph CLI dev command now auto-loads config-file dependencies onto Python's path

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

• ›Enables the dev command to read the dependencies field from the config file and add those directories to Python's path automatically.
• ›Automatically adds the current working directory to Python's path when running the dev command, allowing seamless local module imports.

LangGraph CLI 0.1.58 adds env parameter to pass environment variables from config file to the dev server.

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

env:
  OPENAI_API_KEY: "sk-..."
  MY_CUSTOM_VAR: "value"

• ›Supports passing environment variables from the configuration file to the development server via a new env parameter.

LangGraph CLI 0.1.56 adds Python 3.13 support and Node.js/package.json compatibility validation.

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

from langgraph_cli.config import validate_config_file

config = validate_config_file("langgraph.json")

• ›Supports Python 3.13 as a valid runtime in langgraph-cli config.
• ›Adds validate_config_file() function that loads and validates config files in a single call.
• ›Validates Node.js version compatibility against package.json when present in a project.
• ›Introduces MIN_NODE_VERSION and MIN_PYTHON_VERSION constants for centralized version requirement enforcement.

LangGraph CLI gains a langgraph dev command for running the API server in development mode with hot reloading.

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

$ langgraph dev --port 8123 --no-browser --config langgraph.json

$ pip install "langgraph-cli[inmem]"

• ›New langgraph dev command runs the LangGraph API server in development mode with hot reloading and options for --host, --port, --no-reload, --config, --n-jobs-per-worker, --no-browser, and --debug-port.
• ›New inmem extras entry enables lightweight in-memory API support via pip install "langgraph-cli[inmem]".

LangGraph 0.2.51 adds checkpoint forking to Pregel via a new __copy__ node.

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

• ›Adds checkpoint forking in Pregel via a new __copy__ special node: when as_node="__copy__" and values=None, creates a copy of the checkpoint with a "fork" source marker and preserved parent metadata.

LangGraph checkpoint 2.0.5 adds disk-persistent checkpoints via PersistentDict and a configurable MemorySaver storage backend.

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

from langgraph.checkpoint.memory import MemorySaver, PersistentDict

with MemorySaver(factory=lambda: PersistentDict("/tmp/checkpoints.pkl")) as saver:
    # compile and run your graph with `saver` as the checkpointer
    graph = my_graph.compile(checkpointer=saver)
    graph.invoke({"messages": []}, config={"configurable": {"thread_id": "session-1"}})

• ›New PersistentDict class provides dictionary-like checkpoint storage backed by disk, using atomic writes for data safety.
• ›Adds a factory parameter to MemorySaver to swap in custom storage backends, including the new PersistentDict.

LangGraph 0.2.50 adds the ability to create snapshot checkpoints without modifying graph state.

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

await graph.aupdate_state(config, values=None, as_node=None)

• ›Enables creating checkpoint snapshots mid-execution via aupdate_state without applying any state changes (pass values=None, as_node=None).

LangGraph 0.2.49 adds checkpoint copying and a debug parameter to graph execution loops.

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

graph.update_state(config, values=None, as_node=None)

• ›Supports copying the current checkpoint by calling update_state with both values=None and as_node=None.
• ›Adds a debug parameter to loop creation in Pregel for improved visibility into graph execution.

LangGraph CLI gains a new project scaffolding command, Docker Compose generation, and five built-in agent templates.

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

$ langgraph new my-agent-project

$ langgraph dockerfile --add-docker-compose langgraph.json

• ›Adds new command to scaffold LangGraph projects interactively from five built-in templates (minimal chatbot, ReAct Agent, Memory Agent, Retrieval Agent, Data-enrichment Agent).
• ›Adds --add-docker-compose flag to the dockerfile command, generating a docker-compose.yml, .env, and .dockerignore alongside the Dockerfile.
• ›Adds --version flag to display the installed CLI version.

langgraph-checkpoint 2.0.4 adds INTERRUPT and RESUME constants to support graph execution interruption and resumption.

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

from langgraph.checkpoint.serde.types import INTERRUPT, RESUME

# Check whether a checkpoint write corresponds to an interrupt or resume
def is_interrupt_write(write):
    return write.channel in (INTERRUPT, RESUME)

• ›Adds INTERRUPT and RESUME constants to langgraph.checkpoint.serde.types, enabling interrupt and resume operations in graph execution checkpointing.
• ›Reserves checkpoint write index values -3 and -4 for interrupt and resume operation types in WRITES_IDX_MAP.

LangGraph SDK 0.1.36 adds Command-based graph control, rollback cancellation, and a new messages-tuple stream mode.

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

async for chunk in client.runs.stream(
    thread_id,
    assistant_id,
    command={"resume": "user_approved"},
    stream_mode="messages-tuple",
):
    print(chunk)

await client.runs.cancel(thread_id, run_id, action="rollback")

• ›Adds command parameter to stream(), create(), and wait() run methods, enabling direct node interaction and state manipulation without requiring input.
• ›Adds new Command type with send, update, and resume operations for fine-grained graph execution control.
• ›Adds Send typed dictionary to support direct node targeting during runs.
• ›Enhances cancel() with a new action parameter supporting "interrupt" (default) or "rollback" modes to control cancellation behavior.
• ›Adds CancelAction type to the schema to back the new cancellation modes.

LangGraph 0.2.47 adds resumable interrupts via a new interrupt() function and Command(resume=…) parameter.

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

from langgraph.types import interrupt, Command

def review_node(state):
    # Pause execution and surface data to the caller
    decision = interrupt({"payload": state["draft"], "prompt": "Approve this draft?"})
    # Execution resumes here once Command(resume=...) is issued
    return {"approved": decision}

# From outside the graph, resume after the interrupt:
graph.invoke(Command(resume=True), config=config)

• ›Adds interrupt() function in langgraph.types enabling nodes to pause and later resume with specific values, with namespace tracking for accurate resumption.
• ›Adds a resume parameter to the Command class to control resumption of graph execution after an interrupt.
• ›Adds RESUME constant in langgraph.constants to identify values used to resume a node after an interrupt.
• ›Adds NULL_TASK_ID constant in langgraph.constants to handle writes not associated with any specific task, enabling global writes independent of task execution.
• ›Supports pushing new tasks during graph execution, improving dynamic task scheduling.

LangGraph 0.2.46 adds add_sequence for linear node chains, GraphCommand class, and explicit checkpointing opt-out.

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

graph = StateGraph(MyState)
graph.add_sequence([
    ("ingest", ingest_node),
    ("analyze", analyze_node),
    ("summarize", summarize_node),
])
app = graph.compile()

subgraph = StateGraph(SubState)
subgraph.add_node("step", step_node)
subgraph.set_entry_point("step")
compiled_sub = subgraph.compile(checkpointer=False)

from langgraph.graph.state import GraphCommand

def router_node(state):
    if state["needs_review"]:
        return GraphCommand(goto="human_review", update={"routed": True})
    return GraphCommand(goto="auto_approve")

• ›Adds add_sequence() method to StateGraph for declaratively building a linear chain of nodes with edges auto-wired between them.
• ›Introduces GraphCommand class (replacing deprecated Control) with a goto parameter for directing graph flow and updating state.
• ›Supports passing False to StateGraph.compile(checkpointer=False) to explicitly disable checkpointing in a graph or subgraph.

LangGraph Checkpoint 2.0.3 adds CommandProtocol serialization support in JSON and MessagePack formats.

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

• ›New CommandProtocol interface in langgraph.checkpoint.serde.types enables serialization of command objects (including update and send operations) that mirror the Command type from LangGraph.
• ›Extends JsonPlusSerializer to serialize CommandProtocol objects in both JSON and MessagePack formats by encoding their attributes.

LangGraph 0.2.45 adds a Control class so node functions can steer graph flow and send values to destination nodes directly.

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

from langgraph.types import Control

def router_node(state: dict) -> Control:
    if state["score"] > 0.9:
        return Control(goto="high_confidence_node", update={"routed": True})
    else:
        return Control(goto="low_confidence_node", update={"routed": True})

• ›New Control class lets node functions simultaneously update state and direct graph flow — including triggering specific next nodes or sending values to them.
• ›Nodes can now declare their potential destination nodes via type annotations on their return type, enabling static graph validation of routing paths.
• ›New SELF constant represents the implicit branch created to handle Control return values.
• ›Metadata is now preserved across update_state / aupdate_state calls, so checkpoint metadata survives incremental updates.

LangGraph CLI 0.1.53 adds JavaScript/TypeScript project templates and arbitrary Docker build argument passthrough.

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

• ›Adds a JavaScript/TypeScript project template for scaffolding LangGraph.js applications, including TypeScript config, ESLint, Jest, and sample StateAnnotation-based graph.
• ›Enables passing arbitrary Docker build arguments directly to the Docker build process in the build command.
• ›Adds automatic Node.js package manager detection (npm, yarn, pnpm) based on lock files, selecting the correct install and build commands automatically.

LangGraph 0.2.44 adds chat history validation for ReAct agents and messages-tuple stream mode for remote graphs.

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

from langgraph.errors import ErrorCode

# The validation runs automatically inside create_react_agent;
# catch it explicitly to handle incomplete histories gracefully.
try:
    result = agent.invoke({"messages": chat_history})
except ValueError as e:
    if ErrorCode.INVALID_CHAT_HISTORY in str(e):
        print("Chat history has unmatched tool calls:", e)

from langgraph.pregel.remote import RemoteGraph

remote = RemoteGraph(graph_id="my-graph", url="https://my-deployment.example.com")
for chunk in remote.stream({"messages": []}, stream_mode="messages-tuple"):
    print(chunk)

• ›Adds INVALID_CHAT_HISTORY error code and _validate_chat_history function to catch mismatched tool call / tool response pairs in chat history before they reach the LLM.
• ›Supports messages-tuple stream mode format for RemoteGraph, automatically mapping it to the messages mode.
• ›Improves RemoteGraph visualization by resolving meaningful node names from node data instead of falling back to an empty string.

Letta 0.5.3 adds a CLI token counter, Together AI support, and password-protected server endpoints.

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

$ letta server --secure

$ /tokens

• ›Adds letta server --secure flag to password-protect Letta server endpoints.
• ›Adds /tokens command to the Letta CLI to display a token counter for the current context.
• ›Adds support for Together AI endpoints via the /completions API.
• ›Migrates the Letta Docker image to the letta/letta Dockerhub repository.

Letta 0.5.2 adds agent tags for user association, tool rules to constrain agent execution order, and agent listing by name.

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

# Create an agent tagged with a user ID
agent = client.create_agent(tags=["user_abc123"])

# Retrieve all agents for that user
agents = client.get_agents(tags=["user_abc123"])

• ›Adds AgentState.tags field plus tags parameter to client.create_agent() and client.get_agents() for associating agents with end users or other identifiers.
• ›Introduces TerminalToolRule(tool_name=...), InitToolRule(tool_name=...), and ToolRule(tool_name=..., children=[...]) tool rule classes, passed via tool_rules in client.create_agent(), to enforce required call order and termination conditions per agent.
• ›Adds ability to list agents by name via the REST API and Python SDK.
• ›Adds ability to disable the initial message sequence during agent creation.
• ›Moves docker run letta/letta to run on port 8283 (previously 8083).

PydanticAI v0.0.3 adds streamed responses, dependency override support, and expanded Gemini model coverage.

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

• ›Adds streamed response support, enabling agents to consume model output incrementally as it arrives.
• ›Allows overriding dependencies at runtime (e.g. in testing) via the new dependency override mechanism.
• ›Changes Agent initialization to accept a deps type rather than a deps instance, decoupling agent definition from runtime dependencies.
• ›Expands Gemini model coverage with additional test and integration support.
• ›Adds a chat application example with streaming support to the examples library.

Semantic Kernel Python 1.16.0 adds Azure AI Inference tracing and promotes the OpenAPI plugin to preview.

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

• ›Adds Azure AI Inference tracing SDK integration for observability into Azure AI Inference calls.
• ›Promotes the OpenAPI plugin to preview status, signaling increased stability for production use.

Semantic Kernel .NET 1.30.0 adds Map Step for Processes, AdditionalMessages and IAutoFunctionInvocationFilter for OpenAIAssistantAgent, and Copilot Agent Plugin support.

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

• ›Adds IAutoFunctionInvocationFilter support for OpenAIAssistantAgent, enabling auto-function invocation filtering in agent workflows.
• ›Adds AdditionalMessages support for OpenAIAssistantAgent to pass extra messages when invoking an assistant run.
• ›Adds incomplete status to the termination check for OpenAIAssistantAgent, so runs that end with an incomplete status are handled correctly.
• ›Introduces Map Step feature for .NET Processes, enabling fan-out/fan-in parallel step execution within a process.
• ›Adds support for Copilot Agent Plugins in .NET, allowing plugins authored for Microsoft Copilot to be imported and used.

Semantic Kernel Python 1.15.0 adds audio I/O, Azure Cosmos DB NoSQL vector store, Google Search, and vector search across Weaviate, Redis, CosmosDB, and Qdrant.

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

• ›Adds Azure Cosmos DB NoSQL Vector Store and Collection implementation, enabling vector storage and retrieval against CosmosDB NoSQL.
• ›Adds vector search to CosmosDB NoSQL Collections, Weaviate (including support for unnamed vectors), Redis collections, and Qdrant Collection.
• ›Introduces Google Search as a Text Search implementation.
• ›Adds audio-to-text capability for speech transcription workflows.
• ›Adds text-to-audio capability for speech synthesis workflows.

Semantic Kernel .NET 1.29.0 promotes Liquid templates, adds Ollama function calling, and stabilizes VectorStore and agent serialization APIs.

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

• ›Promotes Liquid prompt template support from experimental to preview status.
• ›Adds function calling support to the MS AI Ollama connector.
• ›Removes the experimental flag from VectorStore implementations, marking them stable.
• ›Removes the experimental attribute from the new function calling model classes, marking them stable.
• ›Adds AgentChat serialization support for persisting and restoring agent chat state.

Semantic Kernel 1.28.0 adds OpenAI image detail level support, OpenAPI security scheme access, multi-server parsing, and Dapr complex-type serialization.

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

• ›Adds support for the OpenAI image detail level property in image content.
• ›Exposes the security scheme and requirement for OpenAPI functions, giving callers access to auth metadata on imported API operations.
• ›Supports parsing multiple servers from an OpenAPI document.
• ›Adds complex type serialization support for Dapr events and messages in the Process Framework.
• ›Simplifies event emission in Process Framework steps.

Semantic Kernel Python 1.14.0 adds vector and text search plus in-memory vector search support.

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

• ›Adds vector and text search capability to the Semantic Kernel Python library, with Azure AI Search hotel concept samples demonstrating implementation.
• ›Adds vector search support to the In Memory collection, enabling local in-process similarity search without an external vector store.

Semantic Kernel 1.27.0 adds audio timestamp granularities, process-level error handling, and richer KernelFunction metadata.

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

var settings = new GeminiPromptExecutionSettings
{
    AudioTimestamp = true
};
var result = await kernel.InvokeAsync(audioToTextFunction, new KernelArguments(settings));

• ›Adds AudioTimestamp property to GeminiPromptExecutionSettings to control audio timestamp output for Gemini models.
• ›Adds Audio-to-Text Timestamp Granularities support for OpenAI and AzureOpenAI audio transcription.
• ›Exposes the REST API operation and operation path in KernelFunction.Metadata, giving plugins richer introspection over the underlying HTTP surface.
• ›Adds process-level error handler support in SK Processes (Processes State Management Part 2), enabling structured error recovery in multi-step process graphs.
• ›Improves logging for the function calls processor and KernelFunction, making agent execution traces more observable.

browser-use 0.1.7 migrates to Playwright and goes fully async from agent to DOM

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

• ›Switches the entire stack from agent to DOM to async, enabling non-blocking browser automation throughout the library.
• ›Replaces the previous browser backend with Playwright, improving speed and reliability for browser-driven workflows.
• ›Supports both async and sync registered functions, letting callers mix execution models when extending the agent.

browser-use 0.1.1 adds custom agent function calls, action history, and token cost approximations

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

• ›Supports custom function calls registered alongside the agent's built-in browser functions, enabling practitioners to extend agent behavior with their own actions.
• ›Adds a history of all agent actions, giving practitioners a full audit trail of what the agent did during a session.
• ›Adds token cost approximations so practitioners can estimate LLM spend per agent run.
• ›Improves HTML processing and XPath extraction for more reliable element targeting.
• ›Highlights clickable elements with rounded overlays on screenshots for clearer visual feedback.

camel-ai v0.2.7 adds Notion, Apify, Tavily, GitHub, and Data Commons toolkits plus 01 and Qwen model platform support.

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

retriever.process(content="https://example.com/doc", extra_payload={"source": "internal", "priority": 1})

• ›Adds extra_payload parameter to VectorRetriever.process() for passing additional data through the retrieval pipeline.
• ›Adds author assignment support to the Google Scholar toolkit.
• ›New Notion toolkit integration for reading and writing Notion content from agents.
• ›New Apify toolkit integration for running Apify actors from agent workflows.
• ›New Tavily search toolkit integration for web search inside agents.

Jan v0.5.8 integrates Cortex.cpp as a backend provider and adds a new nightly app channel.

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

• ›Integrates Cortex.cpp as a backend provider, with Jan APIs proxied to Cortex.cpp.
• ›Adds a new nightly app release channel for early access builds.
• ›Displays model ID on the local API server page.
• ›Expands clickable areas in the ribbon panel for easier navigation.
• ›Adds Qwen2.5-Coder 14B and 32B models to the model hub.

KoboldCpp v1.78 adds Flux and SD 3.5 image generation, new --nofastforward flag, and a /.well-known/serviceinfo identity provider endpoint.

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

$ koboldcpp.exe --model sd35-medium.safetensors --sdt5xxl t5xxl.safetensors --sdclipl clip_l.safetensors --sdclipg clip_g.safetensors

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

• ›Adds --sdt5xxl, --sdclipl, and --sdclipg CLI flags to load individual T5XXL, CLIP-L, and CLIP-G components for Flux and SD 3.5 image generation (supports URL resources).
• ›Adds --nofastforward flag to force full prompt reprocessing on every request, enabling more repeatable and consistent inference results.
• ›Adds /.well-known/serviceinfo common identity provider endpoint, aligning with AI-Horde, Aphrodite, and TabbyAPI interoperability standards.
• ›Supports Flux and Stable Diffusion 3.5 model architectures for image generation, accepting fp16 or fp8 safetensor models and GGUF models, including all-in-one bundled models.
• ›Adds VAE tiling for more consistent large image handling, enabling stable 1024x1024 generation with SDXL and Flux models.

KoboldCpp v1.77 adds token probability (logprobs) API endpoints, ComfyUI image-gen backend support, and in-chat image generation from instruct mode.

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

$ curl http://localhost:5001/api/extra/last_logprobs

• ›Adds logprobs support over the sync API and a new dedicated /api/extra/last_logprobs endpoint for retrieving token probabilities after both streaming and non-streaming responses.
• ›Response fields prompt_tokens, completion_tokens, and total_tokens now return accurate counts instead of placeholder values.
• ›Adds experimental ComfyUI image generation backend support in KoboldAI Lite — requires ComfyUI launched with --listen --enable-cors-header '*'; no workflow customization needed.
• ›Enables image generation from instruct mode via natural language (e.g. 'Please generate an image of a bag of sand'); on by default when an image model is loaded, regex-driven, and toggleable in settings.
• ›Adds a Token Probability Viewer in KoboldAI Lite (disabled by default, enable in advanced settings) showing a table of alternative token probabilities per response.

ONNX Runtime v1.20 adds MultiLoRA, INT4 embedding, cuDNN Flash Attention, QNN weight sharing, and WebGPU on mobile.

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

• ›Adds ability to serialize pre-packed weights to avoid memory growth on model load.
• ›Adds bfloat16 and float8 data type support in the Python I/O binding API.
• ›Adds INT4 quantized embedding support on CPU and CUDA execution providers.
• ›Adds FP16 support for MatMulNbits, Clip, and LayerNormalization ops on the CPU EP.
• ›Adds cuDNN frontend integration for convolution operators on the CUDA EP.

Ollama v0.4.5 lets ollama push print the uploaded model URL and accepts X-Stainless-Retry-Count from OpenAI clients.

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

• ›Accepts X-Stainless-Retry-Count header used by many OpenAI API clients, improving compatibility.
• ›ollama push now prints the uploaded model URL on ollama.com after a successful push.

Ollama v0.4.4 adds Marco-o1 reasoning model and clean file-redirect output.

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

$ ollama run marco-o1

$ ollama run marco-o1 'Explain the steps to perform a SQL injection attack and how to defend against it' > output.txt

• ›Adds Marco-o1, Alibaba AIDC-AI's open large reasoning model, to the Ollama library.
• ›Redirecting CLI output to a file now suppresses progress bars and spinners, enabling clean log capture.

Ollama v0.4.3 adds Tülu 3 and an updated Mistral Large with improved long context and function calling.

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

• ›Adds Tülu 3, a fully open-source instruction-following model family from the Allen Institute for AI, available via ollama pull tulu3.
• ›Adds updated Mistral Large with improved long context, function calling, and system prompt support, available via ollama pull mistral-large.

Ollama v0.4.2 adds NVIDIA Jetson support, three new models, and improved Modelfile error reporting.

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

$ curl -fsSL https://ollama.com/install.sh | sh

• ›Supports NVIDIA Jetson devices via the standard install script.
• ›Adds Qwen 2.5 Coder in six sizes (0.5B–32B) for code generation tasks.
• ›Adds OpenCoder (1.5B and 8B) with English and Chinese chat support.
• ›Adds Athene V2 (72B) optimised for code completion, mathematics, and log extraction.
• ›ollama create now reports line numbers for Modelfile errors, speeding up authoring.

Phoenix v5.11.0 adds an environment variable for setting the default admin password and blocks playground navigation during active runs.

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

• ›Adds an environment variable to configure the default admin initial password at startup.
• ›Playground now blocks navigation when runs are in progress, preventing accidental loss of in-flight completions.

Phoenix v5.10.0 adds Anthropic tool message support and playground chat completion error display.

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

• ›Supports 'tool' message role for Anthropic in the playground, enabling tool-use conversation flows with Claude models.
• ›Displays chat completion errors inline within the playground output card for faster diagnosis of failed LLM calls.

Phoenix 5.9.0 adds Google AI Studio/Gemini support and major Playground dataset-run capabilities.

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

• ›Adds a GraphQL mutation for chat completion over a dataset, enabling batch prompt runs against dataset examples from the Playground.
• ›Adds Google AI Studio support for Gemini models (API-key-based) as a new LLM provider in the Playground.
• ›Adds a dataset example slideover in the Playground to inspect individual dataset examples and their template application.
• ›Adds streaming output display for Playground runs executed against datasets.
• ›Adds an example run slideover in the Playground for reviewing per-example run results.

Phoenix Playground gains dataset integration, Anthropic tool calls, response format control, and env-var-driven gRPC interceptor extensions.

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

• ›Adds env var configuration for gRPC interceptor extensions, enabling customization of the gRPC layer without code changes.
• ›Adds a non-streaming mode toggle to the Playground UI, letting users switch between streaming and non-streaming LLM calls.
• ›Adds a dataset selector and dataset examples table to the Playground, allowing prompt runs against existing datasets directly in the UI.
• ›Supports Anthropic tool calls in the Playground, expanding provider coverage for structured tool-use workflows.
• ›Supports Response Format configuration in the Playground, enabling structured output control (e.g. JSON mode) from the UI.

Phoenix 5.7.0 adds a chat completion mutation, cross-provider tool-call schema conversion, and streaming dataset runs in the Playground.

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

• ›Adds response_format invocation parameter to the Playground, enabling structured-output control per LLM call.
• ›Adds a chatCompletion GraphQL mutation for programmatic chat completion requests.
• ›Supports converting tool call schemas between providers, enabling cross-provider prompt portability.
• ›Playground now streams chat completions over a full dataset, letting users batch-test prompts at scale.
• ›Playground persists model config (model name, parameters) per provider in user preferences.

Langfuse v2.92.0 adds server-side LLM invocation tracing, single-trace API via ClickHouse, and an SDK API for observations by ID.

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

• ›Adds SDK API endpoint to fetch observations by ID.
• ›Adds API endpoint to fetch a single trace via ClickHouse.
• ›Adds a service endpoint for failed BullMQ events.
• ›Adds server-side tracing of LLM invocations at the core level.

Langfuse v2.91.0 adds evals on dataset runs, media UI support, ClickHouse-backed datasets/sessions/scores, and a dataset run peek view.

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

• ›Adds a configure to read from ClickHouse only mode, serving traces, dataset features, dataset results, and scores entirely from ClickHouse — unlocking higher-scale query paths for traces, sessions, and public API score/session lookups.
• ›Enables LLM evaluations triggered directly via dataset runs (evals-on-datasets feature flag removed, now generally available).
• ›Adds UI support for media in traces and observations.
• ›Adds a peek view on the dataset run compare table, with a header, so users can inspect individual run items inline without leaving the comparison view.
• ›Shows linked evaluators directly on the dataset page so teams can see which eval configs are associated with a dataset at a glance.

Langfuse v2.90.0 adds multimodal media upload/download endpoints and generation metrics for the prompts table.

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

• ›Adds media upload and download endpoints for multimodal support.
• ›Adds generation count and metrics (e.g. cost, latency) to the prompts table.
• ›Adds a query parameter to the healthcheck endpoint that enables failure responses when the database is unavailable.
• ›Moves hobby plan usage information to the sidebar in the cloud UI.

Langfuse v2.89.0 expands ClickHouse-backed queries to sessions, scores, and latency dashboards, and adds trace deletion from the UI.

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

• ›Enables deleting traces directly from the UI when using ClickHouse as the backend.
• ›Adds table search support for ClickHouse-backed trace and generation tables.
• ›Adds user charts showing per-user consumption metrics powered by ClickHouse queries.
• ›Adds scores-over-time chart to the dashboard, queried from ClickHouse.
• ›Brings the Sessions API onto ClickHouse reads, covering session listing and detail queries.

Langfuse v2.88.0 adds dataset run comparison view, metadata filters across all UI tables, and Claude Haiku 3.5 model support.

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

• ›Adds metadata filter across all UI tables, enabling filtering by metadata fields in every table view.
• ›Adds a dataset run comparison view to compare results across different dataset runs side by side.
• ›Adds support for Claude Haiku 3.5 in model tracking and cost calculation.
• ›Expands dashboard coverage with additional charts powered by ClickHouse, including distinct model queries and a scores table.

Langfuse v2.87.0 adds a new sidebar/nav, flexible cost tracking, ClickHouse-backed traces and generations, eval template creation from config forms, and cloud event usage metering.

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

• ›Adds is_deleted field to ClickHouse traces and observations, enabling soft-delete tracking in the analytics backend.
• ›Extends ClickHouse support to the traces filter options endpoint, traces.countAll API, traces detail view, and generations table — broadening the set of queries that run against ClickHouse instead of Postgres.
• ›Makes cost tracking flexible, allowing custom or overridden pricing models beyond built-in defaults.
• ›Adds a new sidebar and main navigation UI, replacing the previous navigation structure.
• ›Adds an option to update referenced eval configs when creating a new eval template version.

Weave v0.51.20 adds Dataset iteration, OpenAI beta parse API tracking, up/down call navigation, and a number-parsing string op.

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

import weave

weave.init('my-project')
dataset = weave.ref('my-dataset:latest').get()

for row in dataset:
    print(row)

import weave
import openai

weave.init('my-project')
client = openai.OpenAI()

completion = client.beta.chat.completions.parse(
    model='gpt-4o-mini',
    messages=[{'role': 'user', 'content': 'Extract: John is 30 years old.'}],
    response_format=MySchema,
)

• ›Adds tracking support for the OpenAI beta parse API via the openai integration.
• ›Adds a weave_call_id field to LLM completions, plus an option to disable tracking for individual LLM completion calls.
• ›Makes Dataset iterable, enabling direct Python iteration over Weave datasets in user code.
• ›Adds a new string op to weave_query that parses numbers containing thousands and decimal separators.
• ›Adds a feedback replace endpoint that performs a purge and create in a single step.

Weave v0.51.19 adds project-level leaderboards, single-call retrieval from the TS client, and dict serialization of inputs/outputs.

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

• ›Adds option to retrieve a single call by ID from the TypeScript client (weave_ts).
• ›Enables dictify serialization of call inputs and outputs, making them accessible as plain dictionaries.
• ›Adds project-level leaderboards for comparing model/evaluation performance across a project.

Weave v0.51.18 adds an initial scorer suite, a JS SDK, a completions endpoint, leaderboard support, and trace page charts.

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

• ›Adds completions/create endpoint to the Weave backend, enabling programmatic LLM completion requests through the Weave API.
• ›Adds an initial JS SDK (weave_ts) for instrumenting JavaScript/TypeScript applications with Weave tracing.
• ›Adds JS SDK code options to the 'Use' tab in the UI, surfacing JavaScript examples alongside existing language options.
• ›Adds an initial suite of scorers and refactors weave/flow, providing built-in evaluation scorers for LLM outputs.
• ›Adds client and backend support for Leaderboards, enabling ranking and comparison of model evaluation results.

Composio v0.5.49 adds advanced use case search capability.

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

• ›Adds advanced use case search for discovering integrations and actions by use case.

Composio v0.5.47 adds request executor injection for runtime tools and case-insensitive trigger filtering.

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

• ›Supports injecting a custom request executor into the runtime tool, enabling custom HTTP handling at execution time.
• ›Makes trigger filter matching case-insensitive, so trigger names no longer need to match exact casing.

Composio v0.5.46 adds proxy support for custom actions and auto-creates integrations when no ID is provided.

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

• ›Adds proxy support for executing custom actions, enabling custom actions to route through a configured proxy.
• ›Auto-creates a new integration when no integrationId is provided, removing the requirement to pre-provision an integration before connecting.

Composio v0.5.45 auto-creates integrations on initiate_connection when none exists

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

• ›Adds auto-initiation of a new integration when none exists on initiate_connection, removing the need to manually pre-create integrations before starting a connection flow.

Composio v0.5.44 adds execute_request method and friendlier trigger-not-enabled errors.

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

• ›Adds execute_request method for direct HTTP request execution.
• ›Shows a friendly error message when a trigger is not enabled on your account, replacing opaque failures.

Composio v0.5.43 defaults action execution to the 'primary' account label and adds improved callback filter error messages.

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

• ›Automatically executes actions against the account labelled primary when no account is explicitly specified.
• ›Adds improved error messages for wrong callback filters, helping developers diagnose misconfigured trigger callbacks faster.
• ›Improves developer experience for the code analysis tool.
• ›Adds exclude functionality to the file tool.

Composio v0.5.42 adds support for disconnecting and reconnecting trigger subscriptions.

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

• ›Adds support for disconnecting and reconnecting trigger subscriptions, enabling more dynamic lifecycle management of event listeners.

Composio v0.5.39 adds Anthropic computer use tools and refactored SWE-agent support for LangGraph and CrewAI.

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

• ›Adds Anthropic computer use tools integration.
• ›Adds working SWE-agent in LangGraph and CrewAI, plus a PR-review agent in LangGraph, via SWEKit refactoring.

Composio v0.5.38 adds toolset.get_connected_accounts(), streamWait for OpenAI, and auto-update for failed remote apps.

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

connected_accounts = toolset.get_connected_accounts()

• ›Adds toolset.get_connected_accounts() method to retrieve all connected accounts from a toolset.
• ›Adds streamWait method to the OpenAI integration and moves getExpectedParamsForUser in the JS SDK.
• ›Renames getAction to getTools in the JS SDK.
• ›Adds suggestion text and a documentation link to connection-not-found errors to help users self-serve.
• ›Auto-updates apps when a remote app or action fails to load, reducing manual intervention on stale definitions.

MCP Servers 0.2.0 adds Google Maps, GitHub, Brave Search, DuckDuckGo, Filesystem, and SQLite MCP server integrations.

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

$ npm run link-all

• ›Adds npm run link-all script to set up all servers in a single step.
• ›New Google Maps MCP server integration.
• ›New GitHub MCP server integration.
• ›New Brave Search MCP server integration.
• ›New DuckDuckGo MCP server integration.

LanceDB python-v0.17.0-beta.1 adds overwrite/exist_ok modes for remote table creation and remote connection options support.

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

• ›Adds overwrite and exist_ok mode parameters to create_table for remote LanceDB connections, giving callers control over table collision behavior.
• ›Adds support for remote options when establishing a remote LanceDB connection.

LanceDB v0.13.1-beta.0 adds rustls support, ef search param, list_versions, and checkout APIs across SDKs.

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

• ›Adds ef search parameter support for HNSW index queries, giving callers fine-grained control over recall vs. latency trade-offs.
• ›Adds list_versions to the TypeScript, Rust, and remote Python SDKs for programmatic version enumeration.
• ›Adds checkout and checkout_latest to remote SDKs for switching between dataset versions.
• ›Adds rustls as a TLS backend option for the Rust SDK, enabling use without OpenSSL dependencies.

LanceDB python-v0.16.1-beta.0 adds ef HNSW search param, list_versions, checkout, and checkout_latest across remote SDKs.

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

• ›Adds ef search parameter support for HNSW index queries, letting callers tune recall/speed trade-offs at query time.
• ›Adds list_versions to the TypeScript, Rust, and remote Python SDKs for enumerating table versions.
• ›Adds checkout and checkout_latest to the remote SDKs for switching a table to a specific or latest version.
• ›Adds rustls TLS backend support in the Rust SDK as an alternative to the native TLS stack.

LanceDB v0.13.0 adds fast_search, multi-vector queries, VoyageAI and Amazon Bedrock embeddings, and post-filter on FTS.

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

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

results = await table.search([[0.1, 0.2], [0.3, 0.4]]).limit(5).to_list()

results = await table.search('malware signature').with_row_id(True).limit(20).to_list()

• ›Adds fast_search option in Python and Node for faster approximate index searches.
• ›Adds with_row_id support in Python and remote SDK to include internal row IDs in query results.
• ›Adds post-filter support on full-text search (FTS) queries in Python.
• ›Adds optimize_indices support in the synchronous API.
• ›Supports searching multiple query vectors as a single batch query in Python and Node.

LanceDB v0.16.0 adds fast_search, multi-vector queries, VoyageAI/Bedrock embeddings, and FTS post-filtering.

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

results = table.search(query_vector).fast_search().to_list()

results = table.search([vec1, vec2, vec3]).to_list()

results = table.search('threat actor', query_type='fts').where("severity = 'high'").to_list()

• ›Adds fast_search parameter to vector search in Python and Node for approximate, lower-latency ANN queries.
• ›Adds with_row_id support in Python and remote queries, exposing internal row identifiers in search results.
• ›Adds support for post-filtering on full-text search (FTS) results in Python.
• ›Adds optimize_indices to the synchronous Python API, enabling index optimization without async context.
• ›Supports searching multiple query vectors as a single batched query in one call.

LanceDB v0.13.0-beta.2 adds VoyageAI embeddings, multi-vector search, sync index optimization, and remote empty query support.

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

• ›Adds optimize_indices to the synchronous API, allowing index optimization without async wrappers.
• ›Supports searching multiple query vectors as a single query, enabling batch nearest-neighbor lookups in one call.
• ›Adds VoyageAI as a supported embedding provider for automatic vector generation.
• ›Supports remote empty queries, enabling table scans over remote LanceDB connections without a vector or filter predicate.
• ›Publishes win32-arm64-msvc builds to npm, extending native library support to ARM64 Windows environments.

LanceDB python-v0.16.0-beta.1 adds multi-vector search, VoyageAI embeddings, sync index optimization, and remote empty query support.

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

• ›Adds optimize_index to the synchronous API, enabling index optimization without async context.
• ›Supports searching multiple query vectors as a single query, enabling batch nearest-neighbor lookups in one call.
• ›Adds VoyageAI as a supported embedding provider integration.
• ›Supports remote empty query, allowing queries against remote tables with no filter or vector specified.

LanceDB v0.13.0-beta.0 adds fast_search, post-filter on FTS, and with_row_id support in Python and Node.

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

• ›Adds fast_search option to vector search in Python and Node for faster approximate query execution.
• ›Adds post-filter support on full-text search (FTS) queries in Python.
• ›Adds with_row_id support in Python and remote environments, enabling row-level result identification.
• ›Transitions the Python remote SDK to use the Rust implementation, improving performance and consistency with other language clients.

LanceDB python-v0.16.0-beta.0 adds fast_search, FTS post-filtering, and with_row_id support for Python and remote clients.

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

• ›Adds fast_search option to vector search in Python and Node SDKs for lower-latency approximate queries.
• ›Adds post-filter support on full-text search (FTS) queries in the Python SDK.
• ›Adds with_row_id support in the Python SDK and remote client, exposing internal row IDs in query results.
• ›Transitions the Python remote SDK to use the Rust implementation, backed by lance 0.19.2-beta.3.

Qdrant v1.12.2 adds memory usage metrics, CPU endianness telemetry, and quantized-data-in-RAM default alongside broad performance improvements.

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

• ›Reports memory usage in metrics and telemetry, giving operators visibility into runtime memory consumption.
• ›Reports storage bytes estimate for each segment in telemetry, enabling finer-grained capacity planning.
• ›Reports CPU endianness in telemetry output, surfacing hardware context alongside other node metadata.
• ›Adds support for reinitializing consensus with new peer URLs, easing cluster reconfiguration without a full restart.
• ›Uses streaming creation of snapshots during shard snapshot transfer, reducing peak memory pressure during transfers.

Weaviate v1.26.11 adds the multi2vec-jinaai multimodal embedding module.

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

• ›Adds the multi2vec-jinaai module, enabling multimodal vectorization via Jina AI's multi2vec models.

Weaviate v1.25.26 adds the multi2vec-jinaai multimodal embedding module.

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

• ›Adds multi2vec-jinaai module, enabling multimodal vectorization via Jina AI's embedding models.

Weaviate v1.25.25 adds the multi2vec-cohere multimodal vectorizer module and extends the Slow Log with richer query diagnostics.

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

• ›Introduces the multi2vec-cohere module, adding Cohere-backed multimodal vectorization support to Weaviate.
• ›Extends the Slow Log with additional information to help determine why a query is slow.

Weaviate v1.27.3 adds multi2vec-cohere to default modules and extends the Slow Log with richer query diagnostics.

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

• ›Adds multi2vec-cohere to the default modules list, enabling multimodal Cohere embeddings without manual module configuration.
• ›Extends the Slow Log with additional information to help determine why a query is slow.

Weaviate v1.26.9 adds the multi2vec-cohere multimodal vectorizer module.

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

• ›Introduces the multi2vec-cohere module for multimodal vectorization using Cohere.

Weaviate v1.27.2 adds dynamic backup locations and a new multi2vec-cohere multimodal vectorizer module.

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

• ›Introduces the multi2vec-cohere module, enabling multimodal vectorization via Cohere's API.
• ›Adds dynamic backup locations, allowing backup destinations to be configured at backup time rather than only at startup.