The AI Toolchain — issue -374, September 30, 2024

Aider v0.57.0 adds o1-preview/o1-mini support, recursive read-only dirs, and new Cohere models.

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

$ aider --model o1-preview

• ›Supports OpenAI o1-preview and o1-mini models via --model o1-preview and --model o1-mini.
• ›o1-preview with diff edit format now matches SOTA leaderboard result previously only achieved with whole edit format.
• ›Supports new Cohere 08-2024 models.
• ›Enables recursive directory addition with /read-only.

Aider v0.56.0 adds /report command, --chat-language switch, and prompt caching for Sonnet via OpenRouter.

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

$ /report

$ aider --chat-language Spanish

$ aider --no-suggest-shell-commands

• ›New /report command opens the browser with a pre-populated GitHub Issue for quick bug reporting.
• ›New --chat-language switch sets the spoken language for chat responses.
• ›Enables prompt caching for Sonnet via OpenRouter.
• ›Enables 8k output tokens for Sonnet via VertexAI and DeepSeek V2.5.
• ›--[no-]suggest-shell-commands now controls both prompting for and offering to execute shell commands.

Aider v0.55.0 adds /settings command, crash reporting, devops repo map, and new color/verbose options.

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

$ /settings

• ›New /settings command displays all currently active settings at a glance.
• ›Includes important devops files (e.g., CI configs) in the repo map for better LLM context.
• ›Adds --tool-warning-color setting to customize warning message color.
• ›Adds --verbose debug output for shell commands.
• ›Shares active test and lint commands with the LLM during sessions.

Cline v1.8.0 adds @-mention context injection: pull URLs, workspace problems, files, and folders directly into prompts.

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

• ›New @url mention fetches any URL and converts it to markdown for inline context.
• ›New @problems mention injects workspace errors and warnings directly into the prompt.
• ›New @file mention adds a file's full contents to context with type-to-search support.
• ›New @folder mention adds all files in a folder to context at once.

Cline v1.7.0 adds automatic workspace diagnostics monitoring to detect and fix linter, compiler, and build issues on the fly.

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

• ›Monitors the workspace for linter, compiler, and build issues (missing imports, type errors, etc.) while Claude works, enabling automatic remediation without user intervention.

Cline v1.6.5 adds Azure OpenAI and Google Gemini support, OpenRouter prompt caching, and fuzzy task history search.

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

• ›Supports Azure OpenAI as a model provider.
• ›Supports Google Gemini (free tier: up to 15 requests per minute).
• ›Enables prompt caching on OpenRouter (API cost reflects cache savings).
• ›Adds fuzzy search and sorting to Task History for faster task retrieval.
• ›Task header can now be collapsed to maximize conversation viewing area.

Cline v1.6.0 runs commands directly in your terminal and adds a 'Proceed While Running' button for real-time Claude feedback.

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

• ›Commands now execute directly in the user's terminal via VSCode 1.93 shell integration, replacing the previous sandboxed execution model.
• ›New 'Proceed While Running' button lets Claude continue working while a command is still executing, streaming live output (e.g., server errors) back to Claude so it can react in real time.

Cline v1.5.27 surfaces AI edits in VSCode's Timeline for instant diffing and revert without git.

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

• ›Integrates Claude's file edits into VSCode's Timeline, enabling per-edit diff view and revert to any previous version via local history.

Goose v0.9.0 adds Jinja-templated goosehints, per-repo hints, toolkit listing, and regex-based dangerous command detection.

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

• ›Supports Jinja templating in goosehints files for dynamic hint configuration.
• ›Adds per-repository hints so projects can ship their own Goose context alongside code.
• ›New command to show all available toolkits at a glance.
• ›Adds regex-based checks to detect and flag potentially dangerous shell commands.

OpenHands 0.9.4 adds a --version flag to the CLI and reduces Gemini safety thresholds.

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

• ›Adds --version flag to the OpenHands CLI for quick version inspection.
• ›Reduces safety thresholds for Gemini models, enabling broader task execution with Gemini backends.

OpenHands 0.9.3 adds interactive command support and a redesigned settings modal.

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

• ›Supports interactive terminal commands, enabling agents to handle prompts that require user input mid-execution.
• ›Redesigned settings modal with an updated UI for configuring the service.
• ›Makes prompt caching opt-in rather than enabled by default, giving users explicit control over caching behavior.

Zed v0.153.6 adds tab pinning, vim diff/yank commands, multi-file /file context, and configurable search defaults.

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

{
  "search": {
    "case_sensitive": true,
    "whole_word": true
  }
}

{
  "context_servers": {
    "my-mcp-server": {
      "command": "my-mcp-server",
      "env": {
        "API_KEY": "<your-api-key>",
        "LOG_LEVEL": "info"
      }
    }
  }
}

[
  {
    "bindings": {
      "ctrl-backspace": ["DeleteToPreviousWordStart", {"ignore_newlines": true}]
    }
  }
]

• ›Adds search settings section to configure default options enabled in buffer and project searches.
• ›Adds display_name field for custom models in OpenAI and Google Gemini AI provider configuration.
• ›Adds environment variable configuration for context servers through settings, passed to the server process on launch.
• ›Adds ignore_newlines option to DeleteToPreviousWordStart and DeleteToNextWordEnd action bindings in keymap to opt into previous newline behavior.
• ›Adds yaml-language-server configuration via Zed settings (see zed.dev/docs/languages/yaml).

Zed v0.152.3 adds CLI environment passthrough, REPL large-output buffers, 100-user machine support, and AI context-server argument completions.

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

• ›Adds RA_LOG=info zed .-style CLI environment passthrough: terminals opened with workspace: new terminal, tasks, and language servers (including gopls, zls, rust-analyzer) now inherit the environment variables present when zed was invoked.
• ›Adds a readonly buffer for viewing large REPL outputs, plus a button to open full text output in a separate buffer.
• ›Adds argument completions for context server prompts, surfaced as regular slash-command completions in the Assistant.
• ›Adds optional descriptions in prompts/get responses from context servers, displayed as slash command labels.
• ›Adds ability to accept terminal inline assist suggestions without executing them.

Zed v0.151.1 adds inline completion toggle, project search over SSH, SOCKS proxy, 10x faster project search, and new editor/Vim actions.

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

{
  "unnecessary_code_fade": 0.3
}

• ›Adds editor: toggle inline completions action to toggle Copilot/Supermaven inline completions on/off per buffer, overriding any settings.
• ›Adds unnecessary_code_fade setting to control how strongly unused code is visually faded.
• ›Adds soft_wrap value bounded along with EditorWidth and PreferredLineLength minimum values.
• ›Adds new settings to control split direction for horizontal and vertical splits (right/left or top/bottom), similar to Vim's splitright option.
• ›Adds pane: join into next action to merge panes.

CrewAI v0.63.0 adds a unified LLM class, custom memory interfaces, and switches the default model to GPT-4o-mini.

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

from crewai import Agent, LLM

llm = LLM(model="gpt-4o")
agent = Agent(
    role="Security Analyst",
    goal="Identify vulnerabilities in the provided code.",
    backstory="Expert in application security.",
    llm=llm
)

• ›New LLM class provides a unified interface for interacting with language models via LiteLLM.
• ›Supports custom memory interfaces, enabling practitioners to plug in their own memory backends.
• ›Changes the default model to GPT-4o-mini.

CrewAI v0.60.0 drops LangChain, rebuilds the executor, and adds o1-model support with new agent controls.

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

from crewai import Agent

agent = Agent(
    role="Analyst",
    goal="Analyze the dataset",
    backstory="You are a data expert.",
    llm="o1-preview",
    use_system_prompt=False,
    use_stop_words=False
)

from crewai import Agent

agent = Agent(
    role="Researcher",
    goal="Find key insights",
    backstory="You are a senior researcher.",
    max_rpm=10,
    max_iter=5
)

• ›Removes LangChain dependency with a fully rebuilt internal executor for improved reliability.
• ›New use_system_prompt flag on Agent lets you disable system prompts for models that don't support them.
• ›New use_stop_words flag on Agent allows disabling stop words to support o1-series models.
• ›Adds configurable max requests per minute at the crew/agent level.
• ›Adds a configurable maximum number of iterations before an agent is forced to produce a final answer.

CrewAI v0.55.2 adds auto-complete, enriched TaskOutput fields, new install/deploy CLIs, and Pipeline cleanup.

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

$ crewai install

$ crewai deploy

result = crew.kickoff()
for task_output in result.tasks_output:
    print(task_output.name, task_output.expected_output)

• ›Adds auto-complete support for CrewAI inputs.
• ›Adds name and expected_output fields to TaskOutput for richer task result inspection.
• ›New crewai install CLI command for streamlined project setup.
• ›New crewai deploy CLI command to deploy CrewAI projects.
• ›Cleans up and stabilizes the Pipeline feature.

DSPy 2.5.0 adds type casting and enforcement to adapters with a migration notebook.

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

• ›Adds type casting and enforcement to adapters, with an accompanying migration notebook to guide upgrades from older patterns.

DSPy 2.4.16 introduces new dspy.LM and dspy.Adapter classes and adds support for o1 model parameters.

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

• ›Adds dspy.LM and dspy.Adapter classes, foundational new interfaces for language model and adapter management in DSPy 2.5 onwards (existing clients are unaffected).
• ›Supports o1 model parameters in dspy LM configuration.
• ›Enables LangChain objects to be copied within DSPy workflows.

Haystack v2.5.0 adds explicit unsafe=True opt-in for dynamic code execution in routers and adapters, plus new min_top_k for TopPSampler and richer SentenceWindowRetriever output.

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

from haystack.components.routers import ConditionalRouter

router = ConditionalRouter(
    routes=[
        {"condition": "{{query | length > 50}}", "output": "{{chat_message}}", "output_type": "ChatMessage", "output_name": "long_query"}
    ],
    unsafe=True
)

from haystack.components.samplers import TopPSampler

sampler = TopPSampler(p=0.90, min_top_k=3)

• ›Adds unsafe argument to ConditionalRouter and OutputAdapter; set unsafe=True to enable Jinja-template expressions that can return types such as ChatMessage, Document, and Answer — disabled by default to prevent unintended remote code execution.
• ›Adds min_top_k parameter to TopPSampler to guarantee a minimum number of returned documents when top-p sampling selects fewer than desired, backfilling with next-highest-scored documents.
• ›SentenceWindowRetriever now outputs a context_documents field alongside context_windows for each entry in retrieved_documents, exposing the individual Document objects within each context window.

langchain-community 0.3.1 adds SambaNova Cloud chat, Epsilla Cloud vector DB, PebbloTextLoader, and anonymization flag for PebbloSafeLoader.

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

• ›Adds anonymize flag to PebbloSafeLoader to control whether sensitive data is anonymized during document loading.
• ›Adds PebbloTextLoader for loading raw text data through the PebbloSafeLoader pipeline.
• ›Adds SambaNova Cloud chat model as a new community integration (ChatSambaNovaCloud).
• ›Adds support for Epsilla Cloud as a vector database backend.
• ›Enhances MongoDBLoader with flexible metadata configuration and optimized field extraction.

LangChain Core 0.3.6 adds inherited tracing metadata and tags across chain calls.

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

• ›Tracing metadata and tags are now inherited across chain calls, so nested chains automatically propagate context to LangSmith traces without manual forwarding.
• ›Runs LangChainTracer inline during chain execution, reducing tracing latency overhead.

langchain-core 0.3.3 removes beta status from RemoveMessage and adds JS chat model namespace support

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

• ›Promotes RemoveMessage out of beta to stable status.
• ›Supports JavaScript chat model namespaces for cross-runtime serialization compatibility.
• ›Supports loading from path for default namespaces via load.
• ›Achieves Pydantic v2 compatibility across the library.

langchain-milvus 0.1.5 adds sparse embedding vectorstores, array data type support, and multi-database connections.

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

• ›Adds add_db_milvus_connection to support connecting to multiple Milvus databases from a single integration.
• ›Supports creating a vectorstore with sparse embeddings via the Milvus partner integration.
• ›Adds array data type support when creating Milvus collections.

LangChain Core 0.3.1 promotes RemoveMessage out of beta

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

• ›Promotes RemoveMessage from beta to stable in langchain-core.

langchain-chroma 0.1.4 adds image similarity search and Pydantic v2 / FastAPI compatibility.

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

• ›Adds similarity search by image functionality to the langchain_chroma package, enabling multimodal vector store queries.
• ›Adds Pydantic v2 compatibility (v0.3 standard).

langchain-pinecone 0.2.0 adds document IDs to similarity search results and upgrades to Pydantic v2 compatibility.

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

• ›Adds id field to documents returned by similarity search in PineconeVectorStore, enabling callers to correlate results back to their source records without a separate lookup.
• ›Upgrades PineconeVectorStore to full Pydantic v2 compatibility, including migration of @root_validator usage and conversion of Pydantic extras to literals.

langchain-huggingface 0.1.0 adds streaming support for HuggingFace pipelines and env-based param loading.

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

from langchain_huggingface import HuggingFacePipeline

llm = HuggingFacePipeline.from_model_id(
    model_id="gpt2",
    task="text-generation",
)
for chunk in llm.stream("Once upon a time"):
    print(chunk, end="", flush=True)

• ›Adds streaming support to HuggingFacePipeline, enabling token-by-token output from locally hosted HuggingFace models.
• ›Supports reading HuggingFace parameters from environment variables, removing the need to hard-code credentials or model settings in code.
• ›Adds an option to strip the input prompt from HuggingFace model output, returning only the generated continuation.
• ›Upgrades Pydantic v2 compatibility across the integration (v0.3 series).
• ›Adds TypedDict support for tool schema definitions in the HuggingFace integration.

langchain-azure-dynamic-sessions 0.2.0 adds Pydantic v2 compatibility and renames ToolMessage.raw_output to artifact.

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

• ›Renames ToolMessage.raw_output to artifact across the core library.
• ›Supports ToolCall as Tool input and ToolMessage as Tool output.
• ›Adds Pydantic v2 compatibility.

langchain-experimental 0.3 adds Pydantic v2 compatibility and a new ignore-structured-output option for LLM graph transformers.

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

• ›Adds an option to ignore the structured output method in the LLM graph transformer, providing more flexibility in how graph transformations are processed.
• ›Adds Pydantic v2 compatibility across the library, enabling use in projects that have migrated to Pydantic 2.

LangChain 0.3 adds native Pydantic v2 compatibility across the library.

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

• ›Adds native Pydantic v2 compatibility, allowing LangChain components to be used directly in Pydantic v2 models and projects without v1 compatibility shims.

langchain-community 0.2.17 adds bind_tools to ChatOctoAI and session-expired retry logic for Neo4j Graph.

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

• ›Adds bind_tools method to ChatOctoAI, enabling tool/function binding on OctoAI chat models consistent with other LangChain chat integrations.
• ›Adds automatic session-expired retry handling to the Neo4j graph integration, improving resilience of long-running graph connections.
• ›Adds support for nested dicts in OpenAI community integration.

langchain-core 0.2.40 adds keyword-like runnable config passing and broader import mappings for serialization.

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

• ›Adds keyword-like argument passing for runnable config, enabling more ergonomic config propagation through chains.
• ›Expands import mappings in loads to support additional object types during deserialization.

langchain-pinecone 0.2.0.dev1 adds document IDs to similarity search results

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

• ›Adds id field to documents returned by similarity search in PineconeVectorStore, making it possible to reference or act on retrieved documents by their Pinecone vector ID.

LangChain Community 0.3.0.dev2 adds bind_tools to ChatOctoAI and session-expired retry logic for Neo4j Graph.

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

• ›Adds bind_tools method to ChatOctoAI, enabling tool-binding support for OctoAI-hosted chat models.
• ›Adds automatic session-expired retry handling to the Neo4j graph integration, improving resilience for long-running connections.
• ›Adds a None-delta handler in the OpenAI choice streaming path, supporting responses where delta can be None.

langchain-huggingface 0.1.0.dev1 adds streaming support for HuggingFace Pipeline and env-based param loading.

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

• ›Supports reading HuggingFace parameters from environment variables, enabling credential-free config in CI/CD and containerized deployments.
• ›Adds streaming support to the HuggingFace Pipeline integration, enabling token-by-token output for LLM calls.
• ›Adds an option to strip the input prompt from HuggingFace model output, returning only the generated completion.

langchain-mongodb 0.1.9 adds a limit on the most recent documents fetched from MongoDB.

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

• ›Adds the ability to limit the number of most recent documents fetched from a MongoDB database.

langchain-experimental 0.0.65 adds a GLiNER graph transformer and Relik transformer config support.

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

• ›Adds GlinerGraphTransformer for extracting graph structures using GLiNER models.
• ›Adds Relik transformer configuration support for graph transformation pipelines.
• ›Extends LLMGraphTransformer to handle Ollama tool raw schema inputs.

langchain-community 0.2.16 adds Jina search tools, SambaNova v2 API, Intel GPU support, and new loader/retriever options.

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

from langchain_community.document_loaders import CSVLoader

loader = CSVLoader(
    file_path='data.csv',
    content_columns=['description', 'title']
)
docs = loader.load()

• ›Adds content_columns option to CSVLoader to control which columns are included in loaded content.
• ›Adds option to change how DuckDuckGoSearchResults tool converts API outputs into a string.
• ›Adds Jina search tools integrating the Jina reader API.
• ›Adds Intel GPU support to the ipex-llm LLM integration.
• ›Adds SambaNova SambaStudio LLMs API v2 support.

LangChain 0.2.16 adds strict parameter to OpenAIFunctionsAgent and Neo4j self-query support.

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

• ›Adds strict parameter to OpenAIFunctionsAgent in langchain_openai, enabling strict mode for OpenAI function calling.
• ›Adds Neo4j query constructor for the self-query retriever, enabling structured self-querying against Neo4j graph databases.
• ›Updates Qdrant class check in the Self-Query Retriever factory for improved compatibility.

LangChain text-splitters 0.2.4 adds PowerShell and C language support, plus HTTP request parameters for HTMLHeaderTextSplitter.

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

from langchain_text_splitters import HTMLHeaderTextSplitter

splitter = HTMLHeaderTextSplitter(headers_to_split_on=[("h1", "Header 1"), ("h2", "Header 2")])
chunks = splitter.split_text("https://example.com/docs", requests_kwargs={"headers": {"Authorization": "Bearer <token>"}, "timeout": 10})

from langchain_text_splitters import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter.from_language(language="powershell", chunk_size=500, chunk_overlap=50)
chunks = splitter.split_text(open("deploy.ps1").read())

• ›Adds split_text request parameters to HTMLHeaderTextSplitter for controlling HTTP fetch behavior when splitting remote HTML documents.
• ›Adds PowerShell as a supported language in RecursiveCharacterTextSplitter.
• ›Adds C language support in RecursiveCharacterTextSplitter.
• ›Updates SpacyTextSplitter to fully preserve whitespace when strip_whitespace=False.

ChatMistralAI base URL can now be set via environment variable in langchain-mistralai 0.1.13

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

• ›Adds support for setting the ChatMistralAI base URL via an environment variable, enabling runtime endpoint overrides without code changes.

langchain-core 0.2.38 adds multi-key env secret lookup and extra kwargs support on StructuredPrompt.

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

• ›Adds support for multiple environment variable keys in secrets_from_env, allowing a secret to be resolved from a list of candidate env vars in priority order.
• ›Supports additional kwargs on StructuredPrompt, enabling callers to pass extra parameters previously rejected by the constructor.

langgraph-checkpoint-postgres 1.0.10 adds sync and async PostgreSQL store implementations with batch ops, namespace listing, and schema migration.

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

from langgraph.store.postgres import PostgresStore

with PostgresStore.from_conn_string("postgresql://user:pass@localhost/mydb") as store:
    store.setup()  # create tables and run migrations
    store.put(("agents", "session-42"), "state", {"step": 1, "status": "running"})
    item = store.get(("agents", "session-42"), "state")
    print(item)

import asyncio
from langgraph.store.postgres.aio import AsyncPostgresStore

async def main():
    async with AsyncPostgresStore.from_conn_string("postgresql://user:pass@localhost/mydb") as store:
        await store.setup()
        await store.put(("sessions", "user-99"), "context", {"history": []})
        results = await store.search(("sessions",))
        print(results)

asyncio.run(main())

• ›New PostgresStore class provides a synchronous PostgreSQL-backed store with get, put, search, and namespace-listing operations.
• ›New AsyncPostgresStore class mirrors PostgresStore with full async/await support via asyncio for non-blocking database access.
• ›Both stores expose a from_conn_string() context manager for ergonomic connection management.
• ›Both stores include a setup() method to initialize the database schema and run migrations automatically.
• ›Explicit __all__ exports added to the postgres store modules for cleaner programmatic imports.

LangGraph 0.2.29 expands create_react_agent to accept any LanguageModelLike and adds custom store support via configuration.

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

from langgraph.prebuilt import create_react_agent

# model_like is any LanguageModelLike, not necessarily a BaseChatModel
agent = create_react_agent(model=model_like, tools=[my_tool])
result = agent.invoke({"messages": [{"role": "user", "content": "Search for X"}]})

• ›Expands create_react_agent to accept LanguageModelLike instead of only BaseChatModel, enabling use with a broader range of model types.
• ›Adds support for custom stores via configuration in Pregel, with store parameter propagation through the execution stack.
• ›Migrates store implementation to langgraph-checkpoint, updating namespace representation from strings to tuples and switching methods from list/put to search/batch.

LangGraph Checkpoint 1.0.13 introduces a namespaced key-value store API with sync/async ops and an in-memory implementation.

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

from langgraph.store.memory import InMemoryStore

store = InMemoryStore()

# Store a user fact under a namespaced key
store.put(("users", "alice"), "preference", {"theme": "dark"})

# Retrieve it later
item = store.get(("users", "alice"), "preference")
print(item.value)  # {"theme": "dark"}

from langgraph.store.memory import InMemoryStore

store = InMemoryStore()
store.put(("sessions", "s1"), "summary", {"turns": 5})
store.put(("sessions", "s2"), "summary", {"turns": 12})

results = store.search(("sessions",))
for item in results:
    print(item.namespace, item.key, item.value)

• ›Adds BaseStore abstract base class with sync and async CRUD operations (get/aget, put/aput, delete/adelete, search/asearch, list_namespaces/alist_namespaces, batch/abatch) for persistent, namespaced key-value storage.
• ›Introduces Item as the core storage unit, carrying value data, key, namespace path, and timestamp metadata with equality comparison and dict conversion support.
• ›Ships InMemoryStore, a fully-featured in-memory BaseStore implementation backed by Python dicts for prototyping and testing without external dependencies.
• ›Adds AsyncBatchedBaseStore, which automatically coalesces async store operations into batches via a background task for higher throughput.
• ›Extends JsonPlusSerializer to serialize Item objects, enabling store items to round-trip correctly through checkpoint persistence.

LangGraph checkpoint 1.0.12 adds secret-value serialization support in JsonPlusSerializer.

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

• ›Supports serializing objects that implement get_secret_value() in JsonPlusSerializer, enabling proper handling of secure/secret values during checkpoint serialization and deserialization.

LangGraph 0.2.27 adds namespace filtering to subgraph traversal and broadens BaseStore value types.

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

subgraphs = list(graph.get_subgraphs(namespace="my_agent"))

• ›Adds optional namespace parameter to get_subgraphs and aget_subgraphs for filtering subgraphs by name, improving performance in nested-subgraph graphs.
• ›Automatically excludes subgraphs with checkpointing disabled (checkpointer is False) from subgraph enumeration.
• ›Broadens BaseStore value type (V) from dict[str, Any] to Any, enabling storage of arbitrary value types.

LangGraph's ToolNode now supports multimodal tool responses, letting tools return images and structured data alongside text.

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

from langgraph.prebuilt import ToolNode
from langchain_core.tools import tool

@tool
def capture_screenshot(url: str) -> list:
    """Capture a screenshot and return it as image content."""
    image_bytes = fetch_screenshot(url)  # your existing logic
    return [{"type": "image", "source": {"type": "base64", "media_type": "image/png", "data": image_bytes}}]

node = ToolNode([capture_screenshot])

• ›Enhances ToolNode to handle multimodal content in tool responses, preserving image, image_url, text, and json content blocks instead of converting everything to strings.

LangGraph SDK 0.1.31 adds assistant versioning, subgraph streaming, future run scheduling, and a richer Checkpoint type.

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

await client.assistants.set_latest(assistant_id="asst_abc123", version=3)

versions = await client.assistants.get_versions(assistant_id="asst_abc123")
for v in versions:
    print(v.version, v.config)

await client.runs.create(thread_id="thread_xyz", assistant_id="asst_abc123", after_seconds=60)

• ›Adds name parameter to assistant create and update methods for human-readable assistant identification.
• ›Adds get_versions method to retrieve the full version history of an assistant.
• ›Adds set_latest method to promote a specific assistant version to active.
• ›Adds subgraphs parameter to get_state to include subgraph state in thread state responses.
• ›Adds stream_subgraphs parameter to run methods to stream outputs from subgraphs.

LangGraph 0.2.24 adds a new langgraph.types module and error detection for multiple subgraphs inside a single node.

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

from langgraph.types import Send, Interrupt

• ›Introduces langgraph.types module as the new canonical home for core data types including Send and Interrupt.
• ›Adds MultipleSubgraphsError to detect and prevent multiple subgraphs from being invoked inside the same node.

LangGraph 0.2.23 adds token-by-token message streaming and custom node output streaming via two new stream modes.

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

for chunk in graph.stream(inputs, stream_mode="messages"):
    print(chunk)

# Inside a node definition:
def my_node(state, *, write):
    write({"status": "halfway done"})
    return state

# Consuming the stream:
for chunk in graph.stream(inputs, stream_mode="custom"):
    print(chunk)

• ›Adds stream_mode="messages" to stream LLM output token-by-token in real time.
• ›Adds stream_mode="custom" to emit arbitrary output from nodes via a write parameter.
• ›Enhances chat_agent_executor with route_tool_responses to support tools configured with return_direct, bypassing the agent on return.
• ›Introduces AsyncQueue and SyncQueue utilities for higher-performance concurrent streaming.

LangGraph checkpoint 1.0.10 adds MessagePack serialization, scheduled-task tracking, and namedtuple support.

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

• ›Adds MessagePack integration to JsonPlusSerializer as a faster alternative to JSON serialization, with pooled encoders for throughput.
• ›Adds a SCHEDULED special channel constant (value -2) in WRITES_IDX_MAP on BaseCheckpointSaver to track scheduled task status in the checkpoint system.
• ›Adds get_next_version method to InMemorySaver to generate consistent, unique version identifiers for channels.
• ›Extends JsonPlusSerializer to serialize objects exposing _asdict() (e.g., namedtuples).

LangGraph Postgres checkpointer gains custom serializer support and smarter SQL write strategies in v1.0.7

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

from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver
from my_project.serializers import MyCustomSerde

async with AsyncPostgresSaver.from_conn_string(
    "postgresql://user:pass@localhost/mydb",
    serde=MyCustomSerde(),
) as saver:
    await saver.setup()
    # attach saver to your compiled graph
    graph = workflow.compile(checkpointer=saver)

• ›Adds optional serde parameter to AsyncPostgresSaver.from_conn_string() for injecting custom serializers.
• ›Introduces dynamic SQL query selection for checkpoint writes, choosing between upsert and insert-only operations based on channel types in both PostgresSaver and AsyncPostgresSaver.
• ›Adds new INSERT_CHECKPOINT_WRITES_SQL constant enabling insert-only checkpoint write operations alongside the existing upsert path.

LangGraph 0.2.22 adds create_model Pydantic utility and improved subgraph retry resumption.

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

from langgraph.utils.pydantic import create_model
from langgraph.graph import StateGraph

MyState = create_model('MyState', messages=(list, []), step=(int, 0))
graph = StateGraph(state_schema=MyState)

• ›Adds langgraph.utils.pydantic.create_model, a new utility function that creates Pydantic models compatible with both older and newer versions of langchain-core, supporting normal field definitions and root models through a consistent interface.
• ›Adds a deprecation warning when StateGraph is initialized without an explicit state_schema parameter, prompting users to supply one explicitly.

LangGraph 0.2.20 adds dataclass schema support, ToolNode naming, and reduced dependency on langchain-core for config handling.

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

from dataclasses import dataclass, field
from langgraph.graph import StateGraph

@dataclass
class AgentState:
    messages: list = field(default_factory=list)
    step: int = 0

graph = StateGraph(AgentState)

from langgraph.prebuilt import ToolNode

node = ToolNode(tools=[my_tool])
print(node.name)  # "ToolNode"

• ›Adds dataclass support in get_field_default, enabling field defaults (including default factories) to be retrieved from dataclass-based state schemas.
• ›Adds a name attribute (default "ToolNode") to ToolNode for better graph node identification.
• ›Adds local ensure_config, get_callback_manager_for_config, and get_async_callback_manager_for_config in langgraph.utils.config, removing the dependency on langchain-core for config handling.
• ›Adds __slots__ to BaseChannel and all channel subclasses, reducing per-instance memory overhead at scale.

LangGraph 0.2.19 adds Pydantic BaseModel support to ToolNode and improves async/sync runner responsiveness.

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

from pydantic import BaseModel
from langgraph.prebuilt import ToolNode
from langchain_core.tools import tool

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

@tool
def lookup_user(user_id: str) -> str:
    """Look up a user by ID."""
    return f"User: {user_id}"

node = ToolNode([lookup_user])
# AgentState instance is now passed directly — ToolNode reads fields via getattr
result = node.invoke(AgentState(messages=[...], user_id="u-123"))

• ›Supports Pydantic BaseModel as an input type in ToolNode, alongside existing list and dict inputs, for stronger type safety in tool-calling graphs.
• ›Enables ToolNode to detect nested tool injections inside Union and Annotated types.
• ›Improves ToolNode state extraction to work with object attributes via getattr, enabling object-like states alongside dictionaries.
• ›Yields control back to the caller immediately at the start of PregelRunner.tick and atick, improving responsiveness in async and sync applications.

LangGraph 0.2.18 adds scheduled-task tracking, a TaskNotFound exception, and a Pregel.copy() method for cleaner graph customization.

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

from langgraph.errors import TaskNotFound

try:
    result = await pregel_loop.execute_task(task_id)
except TaskNotFound:
    print(f"Task {task_id} no longer exists in the execution graph")

• ›Adds SCHEDULED constant ("__scheduled__") to represent scheduled tasks, included in the RESERVED set of special keys.
• ›Introduces TaskNotFound exception for explicit error handling when the executor cannot locate a task.
• ›Adds Pregel.copy(update) method to create modified Pregel instances without mutating the original graph.
• ›Adds path: tuple[str, ...] field to PregelExecutableTask to track a task's execution path through the graph.
• ›Adds scheduled: bool field to PregelExecutableTask to indicate whether a task has been scheduled.

LangGraph 0.2.17 adds Pydantic v2 support, a new get_field_default utility, and a new SUBSCRIPTIONS constant for channel management.

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

from langgraph.utils.fields import get_field_default
from typing import Optional
from pydantic import BaseModel

class MyState(BaseModel):
    messages: list = []
    user_id: Optional[str] = None

default = get_field_default(MyState.model_fields["messages"])
print(default)  # []

• ›Adds Pydantic v2 support across the library while maintaining Pydantic v1 compatibility, including in ValidationNode which now selects the correct validation method (model_validate/model_dump_json for v2, validate/json for v1) automatically.
• ›Adds new get_field_default utility in langgraph.utils.fields for reliably resolving default values for state schema fields, with improved handling of optional fields, Required/NotRequired annotations, and type hints.
• ›Adds new SUBSCRIPTIONS constant to langgraph.constants, included in the RESERVED set for channel management.
• ›Expands langchain-core dependency range to allow versions up to v0.4.x.

AsyncPostgresSaver gains synchronous wrapper methods for use in mixed sync/async contexts.

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

from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver

async def setup():
    saver = await AsyncPostgresSaver.from_conn_string("postgresql://user:pass@localhost/db")
    return saver

# In a synchronous context:
import asyncio
saver = asyncio.run(setup())

# Now call sync wrappers directly from sync code:
checkpoint_tuple = saver.get_tuple(config)
all_checkpoints = list(saver.list(config))
saver.put(config, checkpoint, metadata, new_versions)

• ›Adds synchronous list(), get_tuple(), put(), and put_writes() methods to AsyncPostgresSaver, backed by asyncio.run_coroutine_threadsafe(), enabling use from synchronous code without restructuring the async saver.
• ›Stores the running event loop on AsyncPostgresSaver instances via self.loop to support the new synchronous dispatch methods.

AsyncSqliteSaver gains synchronous get_tuple, list, put, and put_writes methods for mixed async/sync use.

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

from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver

saver = AsyncSqliteSaver.from_conn_string("checkpoints.db")

# Synchronous put now works without wrapping in asyncio.run()
saver.put(config, checkpoint, metadata, new_versions)

# Synchronous put_writes also available
saver.put_writes(config, writes, task_id)

• ›Adds synchronous get_tuple, list, and put methods to AsyncSqliteSaver, running async equivalents via asyncio.run_coroutine_threadsafe for mixed-context use.
• ›Adds new synchronous put_writes method to AsyncSqliteSaver.

LangGraph 0.2.16 improves nested subgraph detection for accurate visualization of complex graph structures.

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

• ›Enhances get_graph with pre-computed subgraph resolution when using the xray parameter, enabling accurate visualization of complex nested graph structures.
• ›Expands get_subgraphs to discover nested Pregel instances inside RunnableSequence steps, RunnableLambda dependencies, and RunnableCallable function nonlocals.

Semantic Kernel Python 1.10.0 adds DefaultAzureCredential auth, OpenAI json_schema response format, and streaming token usage.

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

• ›Supports DefaultAzureCredential authentication for Azure Resources in Azure OpenAI connectors.
• ›Supports DefaultAzureCredential authentication for AzureAI Inference connectors.
• ›Supports all auth options for Azure AI Search.
• ›Adds json_schema response format support for OpenAI completions.
• ›Exposes token usage data in streaming content responses.

Semantic Kernel .NET 1.21.1 adds generic data model support for the Azure Cosmos DB NoSQL connector.

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

• ›Adds generic data model support to the Azure CosmosDB NoSQL connector, enabling flexible schema-less document operations without predefined entity types.

Semantic Kernel .NET 1.21.0 adds Process orchestration, Agent prompt templates, generic CosmosDB MongoDB model support, and polymorphic chat serialization.

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

await foreach (var response in agent.InvokeStreamingAsync(thread))
{
    Console.WriteLine(response.Content);
}

• ›Adds messages parameter as optional for OpenAIAssistantAgent.InvokeStreamingAsync, removing the requirement to supply a message list on every streaming invocation.
• ›Supports prompt templates for .NET Agents, enabling KernelFunction-based agent definitions to accept structured prompt template inputs.
• ›Updates KernelFunction-based strategies for AgentGroupChat with revised behavior.
• ›Supports polymorphic serialization of ChatMessageContent and its derived classes.
• ›Adds generic data model support for the Azure CosmosDB MongoDB vector store connector.

Semantic Kernel 1.20.0 adds OpenAI Structured Outputs, a new function-calling model, generic vector-store data models, and Prompty file providers for .NET.

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

• ›Adds FunctionCallContent exception handling consistency improvements to the function-calling pipeline.
• ›Introduces OpenAI Structured Outputs support (Option 1 and Option 2) for the OpenAI and Azure OpenAI connectors.
• ›Adds a new function-calling model for .NET (PR #8811), providing an updated API surface for invoking kernel functions.
• ›Adds generic data model and mapper for the Azure AI Search vector store connector, enabling schema-free document storage and retrieval.
• ›Adds generic data model mapper for Qdrant vector store connector.

Semantic Kernel Python 1.9.0 adds Mistral AI function calling support and new abstract AI connector methods.

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

• ›Adds Mistral AI function calling support via the MistralAI AI connector, enabling tool/plugin invocation through Mistral models.
• ›Introduces new abstract methods on the AI Connector base class, expanding the interface for implementing custom AI service connectors.
• ›Adds a parallel function calling sample demonstrating concurrent tool invocation across AI services.

Semantic Kernel .NET 1.19 adds Azure AI Inference and Ollama connectors, streaming for OpenAIAssistantAgent, and Azure Credential support for Cognitive Services.

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

• ›Adds new Azure AI Inference connector, enabling chat and embedding calls through the Azure AI Inference API (#7963).
• ›Adds new Ollama connector for local model inference via Ollama.
• ›Adds streaming support for OpenAIAssistantAgent and AgentChat in the .NET Agents framework.
• ›Switches Azure Cognitive Services authentication from API keys to Azure Credentials (token-based auth).
• ›Adds new Weaviate connector implementing the new memory/vector store design.

Semantic Kernel .NET 1.18.2 adds Azure Cosmos DB connectors, data URI image support in chat templates, and OpenAPI server-variable support.

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

• ›Adds ImageContent support for data URIs in ChatPromptParser, enabling chat prompt templates to embed base64-encoded images directly.
• ›Adds JSON serializer options and user-agent string passthrough from vector store options down to underlying connectors via Vector Store options.
• ›Adds support for OpenAPI descriptions that use server variables, expanding the range of OpenAPI specs Semantic Kernel can consume.
• ›Adds Azure Cosmos DB for MongoDB connector implementing the new memory/vector-store design.
• ›Adds Azure Cosmos DB for NoSQL connector implementing the new memory/vector-store design.

SGLang v0.2.13 adds window attention for Gemma-2, embedding model support, all sampling penalties, chunked-prefill by default, and 2x MLA throughput for DeepSeek v2.

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

$ curl http://localhost:30000/v1/embeddings \
  -H 'Content-Type: application/json' \
  -d '{"model": "intfloat/e5-mistral-7b-instruct", "input": ["query: what is SGLang?", "query: how does MLA work?"]}'

$ curl http://localhost:30000/v1/completions \
  -H 'Content-Type: application/json' \
  -d '{"model": "meta-llama/Meta-Llama-3-8B", "prompt": "Explain quantum entanglement:", "repetition_penalty": 1.1, "frequency_penalty": 0.5, "presence_penalty": 0.3, "min_new_tokens": 50}'

• ›Adds skip_tokenizer_init argument to bypass tokenizer initialization for advanced serving setups.
• ›Adds sampling penalties — frequency_penalty, presence_penalty, repetition_penalty, and min_new_tokens — completing OpenAI-compatible penalty support.
• ›Enables chunked-prefill by default, improving throughput without requiring manual configuration.
• ›Supports the e5-mistral embedding model with a fully OpenAI-compatible embeddings API, including accepting input as a list.
• ›Adds window attention support for Gemma-2 models.

vLLM v0.6.1.post2 adds support for custom torch.compile backends via the plugin system.

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

• ›Adds plugin support for custom torch.compile backends, allowing operators to register their own compilation strategies.

vLLM v0.6.1.post1 adds multi-image Qwen-VL support, FlashInfer multi-step backend, delta-only engine output, and bitsandbytes for Gemma2.

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

• ›Adds engine option to return only deltas or final output (rather than full accumulated text on each step).
• ›Adds FlashInfer backend support for multi-step scheduling.
• ›Adds bitsandbytes quantization support for Gemma2 models.
• ›Supports multiple images for Qwen-VL models.
• ›Removes the engine_use_ray engine option.

vLLM v0.6.1 adds Pixtral, Qwen2-VL, and Llava-Next-Video support, LoRA hot-swap via API, and 2x AWQ throughput.

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

$ python benchmarks/benchmark_serving.py --model mistralai/Mistral-7B-v0.1 --logprobs 5 --dataset-name sharegpt --num-prompts 200

$ python benchmarks/benchmark_serving.py --model mistralai/Mistral-7B-v0.1 --enable-prefix-caching --num-prompts 500

• ›Adds --logprobs argument to benchmark_serving.py for log-probability output during serving benchmarks.
• ›Enables random prefix caching in benchmark_serving.py serving profiling tool.
• ›Supports dynamic LoRA load and unload via the API server without restart.
• ›Adds progress reporting to the batch runner (run_batch.py).
• ›Adds support for NVIDIA ModelOpt static scaling checkpoints.

vLLM v0.6.0 delivers 2x throughput, multi-step scheduling, Tools API streaming, and new model/hardware support

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

$ vllm serve meta-llama/Meta-Llama-3-8B-Instruct --num-scheduler-steps 8

$ vllm serve mistralai/Mistral-7B-Instruct-v0.3 --tokenizer-mode mistral

$ vllm serve meta-llama/Meta-Llama-3-70B-Instruct --quantization bitsandbytes --load-format bitsandbytes

• ›Enables multi-step scheduling via --num-scheduler-steps engine argument (e.g. --num-scheduler-steps 8) to unlock up to 2x throughput versus v0.5.3, with log_probs support included.
• ›Adds json_schema support from the OpenAI protocol for structured output control.
• ›Adds OpenAI-Compatible Tools API with streaming support for Hermes and Mistral models.
• ›Enables chunked prefill and prefix caching simultaneously, previously mutually exclusive.
• ›Publishes Prometheus metrics in the run_batch API.

Ollama v0.3.11 adds ollama stop to unload running models and ships five new models including Qwen 2.5 and Bespoke-Minicheck.

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

$ ollama stop mistral-small

• ›New ollama stop command to unload a running model from memory on demand.
• ›Adds Solar-Pro-Preview (22B), Qwen 2.5 (up to 128K context), Bespoke-Minicheck (fact-checking), Mistral-Small (22B), and Reader-LM (HTML-to-Markdown) to the model library.
• ›Shows an error when importing a model with an invalid number of tokens in the vocabulary, catching bad imports early.
• ›The ollama/ollama container image now starts almost immediately, cutting startup time by ~5 seconds.

Ollama v0.3.10 adds MiniCPM-V multimodal, Yi-Coder, and DeepSeek-V2.5 models plus automatic CUDA 11 fallback for older NVIDIA drivers.

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

• ›Adds Yi-Coder, an open-source code language model series delivering state-of-the-art coding performance under 10B parameters.
• ›Adds DeepSeek-V2.5, combining DeepSeek-V2 general chat and DeepSeek-Coder-V2 coding capabilities in a single model.
• ›Automatically falls back to CUDA 11 for older NVIDIA drivers incompatible with CUDA 12, expanding GPU support without manual configuration.

Phoenix v4.36.0 adds an environment variable to control structured logging output.

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

• ›Adds an environment variable setting to enable structured (JSON) logging for Phoenix server output.

Phoenix v4.34.0 adds finer-grain 'last N' time range selection to the UI.

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

• ›Adds finer-grain 'last N' time range controls for more precise time-window selection when exploring traces and inferences.

Phoenix Evals v0.16.0 adds support for OpenAI o1 preview models.

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

• ›Adds OpenAI o1 preview model support to the Phoenix Evals library.

Phoenix v4.33.0 adds user API keys table, PostgreSQL schema support, Bedrock onboarding, and improved DeleteSystemApiKey mutation.

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

• ›The DeleteSystemApiKey mutation now returns a Query object, enabling callers to refetch dependent data in a single round-trip.
• ›Adds a user API keys management table in the auth UI.
• ›Adds PostgreSQL schema support with a dedicated integration test for production database deployments.
• ›Adds Amazon Bedrock to the onboarding flow.
• ›Renders the database schema in the welcome message when a supported database is configured.

Langfuse v2.81.1 adds optional S3 upload of all incoming events and larger step sizes in the Trace Timeline View.

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

• ›Adds optional upload of all incoming events to S3 (feat(v3)) for infrastructure-level event archival.
• ›Supports larger step sizes in the Trace Timeline View for improved navigation of long traces.

Langfuse v2.81.0 adds API-based API key deletion and async generation exports on cloud.

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

• ›Adds a DELETE endpoint to remove API keys programmatically via the Langfuse API.
• ›Adds async export of generations on the cloud UI, enabling large dataset exports without blocking the browser.

Langfuse v2.79.0 adds custom base path support, trace export, OpenAI o1 models, and drag-and-drop column reordering.

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

• ›Supports custom base path for self-hosted deployments via the NEXT_PUBLIC_BASE_PATH environment variable.
• ›Adds env variables to toggle individual queue consumers on or off (self-host operators can now control which consumers run).
• ›Adds cost tracking and Playground support for OpenAI o1 beta models.
• ›Enables export of traces directly from the UI.
• ›Adds search to the users table.

Langfuse v2.78.0 adds structured logging, a /ready readiness endpoint, and renames provisioning env vars to LANGFUSE_INIT_.

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

• ›Adds /ready HTTP endpoint to separate liveness checks from readiness checks in self-hosted deployments.
• ›Adds structured logging option for self-hosted instances, migrated across the shared package and web API.
• ›Renames headless initialization environment variable prefix from LANGFUSE_PROVISION_ to LANGFUSE_INIT_ for self-hosted instance provisioning.

Langfuse v2.77.0 adds dataset run deletion and automated self-hosted instance provisioning via LANGFUSE_PROVISION_* env vars.

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

$ LANGFUSE_PROVISION_ORG_NAME=my-org \
LANGFUSE_PROVISION_PROJECT_NAME=my-project \
[email protected] \
LANGFUSE_PROVISION_USER_PASSWORD=changeme \
docker compose up

• ›Adds LANGFUSE_PROVISION_* environment variables to automatically provision a self-hosted Langfuse instance with a default organization, project, user, and API keys on first startup.
• ›Adds the ability to delete dataset runs from the UI.

Langfuse v2.76.0 adds synchronous ingestion fallback and resizable dataset item UI.

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

• ›Falls back to synchronous ingestion automatically when the ingestion queue is unavailable, improving reliability during queue outages.
• ›Adds the ability to disable the legacy ingestion queue when required.
• ›Makes the table vs. item detail panel in dataset items resizable.
• ›Pulls usage data in cloud settings from Stripe when available, improving accuracy of usage displays.

Weave v0.51.10 adds an Instructor integration for structured output tracing.

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

• ›Adds an Instructor integration, enabling tracing of structured LLM outputs produced via the Instructor library.

Weave v0.51.8 adds pagination/sorting to object and table APIs, code-capture control, row digests on table mutations, and a chat view for calls.

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

import weave

weave.require_current_call()  # raises if no active call context

• ›Adds require_current_call function that raises an exception when the current call is None, enabling strict call-context assertions in instrumented code.
• ›Adds a setting to control code capture behavior in the Weave library.
• ›Table Creation and Update endpoints now return row digests, enabling callers to track and reference individual rows after writes.
• ›Adds pagination and sorting to object APIs, making large object collections navigable programmatically.
• ›Enables sorting and pagination on Table Query endpoints, supporting large-scale tabular data workflows.

Weave v0.51.7 adds post-processing hooks for call I/O, customizable display names, an Evaluation tab, and background image serialization.

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

• ›Adds post-processing options for call inputs and outputs, enabling transformation or redaction of traced data at ingest time.
• ›Adds customizable display names for ops and calls via feat(weave): Add customizable display names.
• ›Adds a new Evaluation tab to the UI for browsing evaluation results.
• ›Makes Image serialization a background process, unblocking the main thread during large media uploads.
• ›Adds a refresh button to the Calls Table in the UI.

Weave v0.51.6 adds native integration support for Mistral V1.0.

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

• ›Adds integration support for Mistral V1.0, enabling automatic tracing of Mistral client calls.

Weave v0.51.5 adds a Python API for LLM cost tracking and updates the Cohere v2 client integration.

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

• ›Adds a Python API for querying and managing LLM costs (feat(weave): Add python api for costs).
• ›Updates the Cohere integration to support the Cohere Client v2 API.

Weave v0.51.2 adds version-update alerts, image support in Eval Compare, and feedback data in calls stream queries.

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

• ›Adds simple feedback response data to calls_stream_query, enabling retrieval of human feedback alongside call results.
• ›Alerts users in-library when a newer version of Weave is available.
• ›Adds image support in the Eval Compare view, allowing visual outputs to be compared across evaluation runs.

LanceDB python-v0.14.0-beta.0 upgrades to Lance 0.18.0, defaults to file format v2.0, and expands Rust remote client coverage.

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

table = db.create_table("my_table", schema=schema, data_storage_version="legacy")

• ›Passes data_storage_version="legacy" when creating a table to opt out of the new Lance file format v2.0 default.
• ›Adds remote connection support to the LanceDB Rust client, including endpoints for schema, version, count_rows, and write data.
• ›Supports creating empty tables and creating tables from a list of RecordBatch objects in the remote Python SDK.
• ›Defaults the Node API region to us-east-1 when no region is specified for remote connections.

LanceDB v0.11.0-beta.0 adds Rust remote connection support and upgrades Lance to 0.18.0.

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

• ›Adds remote endpoints for schema, version, and count_rows in the Rust SDK.
• ›Adds remote client write data endpoint in the Rust SDK.
• ›Implements Remote connection support for LanceDB Rust client.
• ›Defaults the Node API region to us-east-1 for remote connections.
• ›Supports creating empty tables and creating tables from a list of RecordBatch in the remote Python SDK.

LanceDB v0.10.0 migrates FTS to lance-index, adds bitmap/label-list scalar indexes, reranker improvements, and query offsets across Python, Rust, and Node.js.

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

results = table.search('attack vector', query_type='hybrid').phrase_query(True).to_list()

• ›Migrates full-text search (FTS) from tantivy to lance-index, enabling FTS query and indexing on RemoteTable and AsyncTable.
• ›Adds phrase_query(bool) parameter to hybrid search queries to enable phrase-level FTS matching.
• ›Supports building FTS indexes without positional data for leaner indexes when phrase queries are not needed.
• ›Adds bitmap and label list scalar index types to the Python async API, Node.js API, and remote tables.
• ›Exposes offset in query API across Python, Rust, and Node.js for paginated result retrieval.

LanceDB python-v0.13.0 migrates FTS to lance-index, adds bitmap/label-list scalar indexes, AnswerDotAI rerankers, phrase queries, and offset support.

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

results = table.search('exact phrase here').phrase_query(True).limit(10).to_list()

await table.create_scalar_index('category', index_type='BITMAP')

• ›Migrates full-text search (FTS) from tantivy to lance-index, enabling FTS query and indexing on RemoteTable and AsyncTable.
• ›Supports building FTS indexes without positions, reducing index size when phrase queries are not needed.
• ›Enables phrase_query(bool) on hybrid search queries to toggle phrase matching mode.
• ›Adds BitmapIndex and LabelListIndex scalar index types to the Python async API, Node.js API, and remote tables.
• ›Adds answerdotai rerankers support for hybrid search result reranking.

Milvus 2.4.11 adds static expression views and delete buffer quota logic for improved delete stability.

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

• ›Implements delete buffer quota logic to govern delete throughput and improve delete stability under load.
• ›Adds static view for filter expressions, enabling inspection of query expressions at rest.

Weaviate v1.24.25 adds backup list and cancel endpoints, Jina V3 and new VoyageAI model support, and nested cross-reference depth limits.

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

• ›Adds a backup cancel endpoint, allowing in-progress backups to be programmatically stopped.
• ›Adds a backup list endpoint for querying existing backups via the API.
• ›Adds support for Jina V3 embeddings, including the task parameter (replacing task_type) for JinaAI V3 embedding models.
• ›Introduces new VoyageAI models as supported embedding integrations.
• ›Introduces a limit on nested cross-reference depth in queries to bound query complexity.

Weaviate v1.25.17 adds backup list and backup cancel API endpoints.

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

• ›Adds a backup list endpoint to retrieve existing backups via the API.
• ›Adds a backup cancel endpoint to abort an in-progress backup via the API.

Composio v0.5.26 adds a Google plugin, Sheets DB sync, and skip-default-connector support.

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

• ›Adds support for skipping the default connector via skip default connector (#ENG-1386).
• ›Adds a new Google plugin integration.
• ›Adds Sheets DB sync capability.
• ›Adds integration YAML documentation support.

Composio v0.5.24 adds connection ID specifiers, remote enum opt-out, schema control, and a new Testing tool.

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

• ›Adds support for connection ID specifiers, letting callers target a specific authenticated connection when invoking actions.
• ›Adds support for disabling remote enum fetching, giving offline or air-gapped deployments control over schema resolution behaviour.
• ›Adds support for changing the schema in Code Analysis tools, enabling custom schema configurations.
• ›Adds a new Testing tool to the local toolset.

Composio v0.5.22 adds a SWE Autogen template and re-enables Pusher on listen.

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

• ›Adds a SWE (Software Engineering) Autogen template for automating software engineering agent workflows.
• ›Re-enables Pusher on listen to restore real-time event connectivity.

Composio v0.5.20 adds a JavaScript CLI and file upload/download support.

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

• ›Adds Composio CLI for JavaScript, enabling JS-based workflows to manage Composio directly from the command line.
• ›Adds file upload and download support.

Composio v0.5.17 adds a client Pusher key environment variable for real-time connection configuration.

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

• ›Adds a client Pusher key environment variable for configuring real-time push connections.