The AI Toolchain — issue -381, February 29, 2024

Aider v0.23.0 adds /test command, --openrouter shortcut, and new model aliases for GPT-4 Turbo.

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

$ /test pytest tests/

$ aider --openrouter --model mistralai/mistral-7b-instruct

• ›Adds --model gpt-4-0125-preview and --model gpt-4-turbo-preview (OpenAI alias) as supported model targets; --4turbo remains an alias for --model gpt-4-1106-preview.
• ›Adds --openrouter flag as a shortcut for --openai-api-base https://openrouter.ai/api/v1, enabling one-flag OpenRouter integration.
• ›Adds --skip-check-update flag to suppress the update check on launch.
• ›New /test command runs an arbitrary command and automatically appends its output to the chat when the exit status is non-zero.
• ›Adds /quit as an alias for /exit.

Zed gains an extension registry, new language support, and new editor/assistant settings in v0.123.2.

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

{
  "assistant": {
    "openai_api_url": "https://my-openai-proxy.internal/v1"
  }
}

• ›Adds assistant.openai_api_url setting to configure a custom OpenAI API URL (e.g. for proxies or self-hosted endpoints).
• ›Adds Editor::unique_lines_case_insensitive and Editor::unique_lines_case_sensitive commands for deduplicating lines in a buffer.
• ›Adds ToggleGraphicsProfiler command (also accessible via Help -> Toggle Graphics Profiler) to investigate graphics rendering performance.
• ›Adds zed: extensions command palette action to browse and install extensions from a new Zed extension registry; initial support covers syntax highlighting and themes.
• ›Adds open permalink to line action for linking directly to a specific line.

Zed v0.122.2 adds OCaml/Erlang/Terraform language support, cross-release collaboration, light/dark theme switching, and new editor config keys.

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

"toolbar": {
  "breadcrumbs": true,
  "quick_actions": false
}

"share_on_join": false

• ›Adds share_on_join setting (defaults to true) that automatically shares your project when you join an empty channel.
• ›Adds toolbar config block with breadcrumbs and quick_actions keys to control editor toolbar visibility.
• ›Adds vertical_scroll_offset setting to configure vertical scroll offset in the editor.
• ›Adds four new editor actions — editor::MoveUpByLines, editor::MoveDownByLines, editor::SelectUpByLines, editor::SelectDownByLines — each accepting a line-count argument for cursor movement.
• ›Adds pane::RevealInProjectPanel as an addressable command palette action.

Zed v0.121.5 adds user-defined themes, private-file redaction, six new languages, and richer Vim/collaboration support.

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

{
  "private_files": ["**/.env", "**/secrets.json", "**/*.pem"],
  "redact_private_values": true
}

{
  "experimental.theme_overrides": {
    "editor.background": "#1a1a2e",
    "editor.foreground": "#e0e0ff"
  }
}

• ›Adds private_files setting to settings.json to designate files containing sensitive information, automatically disabling collaboration on matched files.
• ›Adds redact_private_values setting to settings.json to toggle censor bars over variable values in files matching private_files.
• ›Adds experimental.theme_overrides to settings.json for customizing the active theme without creating a full theme file.
• ›Adds support for loading user-defined themes.
• ›Adds LSP support for toml and Elm.

shell-gpt 1.3.1 adds API_BASE_URL config variable to point at custom OpenAI-compatible endpoints.

$ git clone --branch 1.3.1 https://github.com/TheR1D/shell_gpt.git
# already have the repo? check out this version:
$ git checkout 1.3.1

$ API_BASE_URL=https://my-llm-proxy.internal/v1

• ›Adds API_BASE_URL config variable to redirect shell-gpt to any OpenAI-compatible API base, enabling use with self-hosted or alternative LLM endpoints.

shell-gpt 1.3.0 adds multi-backend LLM support via LiteLLM (including Ollama) and role-driven Markdown formatting control.

$ git clone --branch 1.3.0 https://github.com/TheR1D/shell_gpt.git
# already have the repo? check out this version:
$ git checkout 1.3.0

• ›Supports multiple LLM backends via LiteLLM, enabling locally hosted open-source models such as Ollama alongside existing cloud providers.
• ›Controls Markdown formatting per role: including "APPLY MARKDOWN" in a role's description enables formatted output; removing it disables it for that role.
• ›Allows editing the default role description at ~/.config/shell_gpt/roles to globally enable or disable Markdown formatting.

CrewAI v0.14.0rc0 adds crewai-tools integration, Pydantic/JSON task output formatting, and file output support.

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

• ›Adds support for crewai-tools integration.
• ›Adds support for formatting task output as Pydantic objects or JSON.
• ›Adds support for saving task output to a file.
• ›Supports tools with no arguments.
• ›Revamps tools usage logic to properly use function calling.

CrewAI v0.10.0 adds full task output capture, step callbacks, multi-argument tool support via JSON, and shared caching across agents.

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

def my_callback(step):
    print(step)

agent = Agent(..., step_callback=my_callback)
crew = Crew(agents=[agent], ..., step_callback=my_callback)

• ›Adds full_output return from crew kickoff, exposing all individual task outputs in a single result.
• ›Adds step_callback parameter for both Agents and Crews to receive all intermediate reasoning steps during execution.
• ›New tool usage internals now use JSON, unlocking support for tools that require multiple arguments.
• ›Rebuilt caching structure so multiple agents can share the same cache across a crew run.
• ›Adds opt-in sharing of complete crew run data with the crewAI team.

CrewAI v0.5.0 adds task callbacks, hierarchical process support, task references, and parallel task execution.

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

• ›Adds task callbacks, enabling post-execution hooks on individual tasks.
• ›Adds support for a hierarchical process model for structuring agent workflows.
• ›Adds the ability to reference specific tasks from within another task.
• ›Adds parallel task execution, allowing multiple tasks to run concurrently.

LangChain v0.1.8 adds new LLM integrations, vector stores, async cache/embedding methods, and a MongoDB-backed store.

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

from langchain_community.document_loaders import DirectoryLoader

loader = DirectoryLoader('./docs', glob='**/*.md', exclude=['**/test_*', '**/fixtures/**'])
docs = loader.load()

from langchain_community.document_loaders import NotionDBLoader

loader = NotionDBLoader(
    integration_token='<notion_token>',
    database_id='<database_id>',
    request_timeout_sec=30,
    filter={'property': 'Status', 'select': {'equals': 'Published'}}
)
docs = loader.load()

from langchain.embeddings import CacheBackedEmbeddings
from langchain_community.embeddings import OpenAIEmbeddings
from langchain.storage import LocalFileStore

store = LocalFileStore('./embedding_cache')
embedder = CacheBackedEmbeddings.from_bytes_store(OpenAIEmbeddings(), store)

# Non-blocking embedding in an async context
embeddings = await embedder.aembed_documents(['classify this alert', 'lateral movement detected'])

• ›Adds exclude parameter to DirectoryLoader to filter out files when loading from a directory.
• ›Adds name field to BaseMessage in langchain-core for identifying messages.
• ›Adds async methods to CacheBackedEmbeddings for non-blocking embedding cache lookups.
• ›Adds async methods to AstraDBCache, AstraDBChatMessageHistory, and AstraDBBaseStore.
• ›Adds truncation support to VoyageEmbeddings.

LangChain v0.1.7 adds AWS Athena loader, FlashRank reranker, Pebblo safe loader, Yuan2.0 chat, and async cache/tool methods.

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

from langchain_community.vectorstores import DatabricksVectorSearch

vs = DatabricksVectorSearch(
    index=my_index,
    embedding=embeddings,
    text_column="content",
)
retriever = vs.as_retriever(search_type="mmr", search_kwargs={"k": 5, "fetch_k": 20})
docs = retriever.get_relevant_documents("what is data lakehouse?")

• ›Adds mmr and similarity_score_threshold retrieval modes to DatabricksVectorSearch.
• ›Adds delete method to the RocksetDB vector store to support the record manager.
• ›Adds async methods to InMemoryCache.
• ›Adds async methods to VectorStoreQATool.
• ›Adds pagination support to GitHubIssuesLoader for efficient retrieval of large issue lists.

LangChain v0.1.6 adds async retriever/memory methods, LIKE comparator for Qdrant, partial JSON tool parsing, and new NVIDIA Riva runnables.

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

from langchain_community.llms import Bedrock

llm = Bedrock(
    model_id="arn:aws:bedrock:us-east-1::foundation-model/my-custom-model-id",
    region_name="us-east-1",
)
print(llm.invoke("Summarize the following document:"))

• ›Adds partial parsing support to JsonOutputToolsParser, enabling streaming tool-call output to be consumed before the full JSON is complete.
• ›Adds LIKE comparator (full-text match) to Qdrant self-query filtering.
• ›Adds a validation error handler to BaseTool so tool invocation failures surface cleanly instead of raising unhandled exceptions.
• ›Adds async methods to MultiVectorRetriever, BaseChatMessageHistory, and BaseMemory, enabling non-blocking retrieval and history operations.
• ›Adds SelfQueryRetriever support to PGVector, enabling structured metadata filtering over Postgres vector stores.

LangChain v0.1.5 adds new integrations, async methods, TTL support, image prompt templates, and callable FAISS filters.

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

from langchain_community.chat_models import ChatOllama

llm = ChatOllama(model="mistral", num_predict=256)
response = llm.invoke("Summarize the OWASP Top 10 in one paragraph.")
print(response.content)

from langchain_community.document_loaders import AssemblyAIAudioTranscriptLoader

loader = AssemblyAIAudioTranscriptLoader(transcript_id="<your-transcript-id>")
docs = loader.load()
print(docs[0].page_content)

• ›Adds num_predict option support to ChatOllama for controlling token generation length.
• ›Adds cookie support to WebBaseLoader's fetch method for authenticated page loading.
• ›Adds add_bulk_messages to BaseChatMessageHistory interface for batch message writes.
• ›Adds async methods (aload, etc.) to BaseLoader base class, enabling non-blocking document ingestion pipelines.
• ›Adds async methods to AstraDBLoader for non-blocking document retrieval.

LlamaIndex v0.10.13 adds fsspec support, mistral-large, last-token pooling for HuggingFace embeddings, and a KodaRetriever pack.

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

• ›Adds fsspec support to SimpleDirectoryReader, enabling reads from any fsspec-compatible filesystem (S3, GCS, ADLS, etc.).
• ›Adds a llama-pack for KodaRetriever with on-the-fly alpha tuning for hybrid retrieval weighting.
• ›Supports mistral-large as a new model option.
• ›Adds last-token pooling mode for HuggingFace embedding models such as SFR-Embedding-Mistral.

LlamaIndex v0.10.7 adds a Self-Discover LlamaPack for structured reasoning workflows.

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

• ›Adds Self-Discover LlamaPack, enabling structured self-discovery reasoning workflows via the llamapack interface.

LlamaIndex v0.10.6 adds NomicHFEmbedding and MinioReader integrations.

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

• ›Adds NomicHFEmbedding class for Nomic embedding model support via Hugging Face.
• ›Adds MinioReader class for ingesting data directly from MinIO object storage.

LlamaIndex v0.10 splits into a llama-index-core package plus hundreds of separate integration packages, and deprecates ServiceContext.

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

from llama_index.llms.openai import OpenAI

llm = OpenAI(model="gpt-4")

• ›Introduces llama-index-core as a standalone PyPI package, with all integrations (LLMs, embeddings, vector stores, data loaders, callbacks, agent tools) split into individually versioned PyPI packages while preserving namespace imports (e.g. from llama_index.llms.openai import OpenAI still works).
• ›Consolidates the former llama-hub repository into the main llama_index repo under llama-index-integrations, making LlamaHub the single registry for all integrations.
• ›Deprecates ServiceContext in favour of directly specifying arguments or setting a global default, removing the centralized abstraction for managing LLMs, embeddings, chunk sizes, and callbacks.

AutoGen v0.2.14 adds callable summary methods, runtime logging, Azure assistant API support, and GroupChat agent lookup.

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

import autogen

def my_summary(recipient, messages, sender, config):
    return messages[-1]['content'][:200]

autogen.initiate_chats([
    {"sender": agent_a, "recipient": agent_b, "message": "Start task", "summary_method": my_summary},
    {"sender": agent_b, "recipient": agent_c, "message": "Continue",   "summary_method": my_summary},
])

• ›Adds autogen.initiate_chats top-level function to start sequential chats initiated by different agents.
• ›Adds callable summary_method support to initiate_chats, allowing custom summarization logic to be passed as a Python callable.
• ›Adds nested_agents property and agent_by_name lookup to GroupChat, enabling retrieval of nested agents and name-based agent resolution.
• ›Adds runtime logging capability to ConversableAgent-based conversations for recording and auditing agent interactions.
• ›Adds Azure assistant API support to GPTAssistantAgent.

AutoGen v0.2.13 adds a long-context handling agent capability and a new extensible code execution interface with stateful executors.

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

• ›Adds a new extensible agent capability for long context handling, enabling agents to operate over inputs that exceed standard context windows.
• ›Introduces a new extensible code execution interface with support for stateful executors, allowing code state to persist across execution steps.

AutoGen v0.2.12 adds SocietyOfMind function-calling support, exposes filter_config, and introduces multiple sequential chats and a Discord bot.

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

from autogen import filter_config

config_list = [
    {"model": "gpt-4", "api_key": "..."},
    {"model": "gpt-3.5-turbo", "api_key": "..."}
]
filtered = filter_config(config_list, {"model": ["gpt-4"]})

• ›Exposes filter_config function as a public API for filtering LLM config lists.
• ›Adds max_tokens field to AutoGen Studio's LLMConfig, enabling token-limit control in Studio-configured models.
• ›Enables SocietyOfMind agents to participate in function calling and tool use workflows.
• ›Introduces multiple sequential chats interface, allowing a sequence of chats to be programmed with results carried forward between them.
• ›Introduces AutoAnny, a Discord bot built with AutoGen demonstrating real-time agent interactions on Discord.

AutoGen v0.2.11 adds FSM-based group chat, sequential multi-chat chaining, and AutoGen Studio workflow export and skill editing.

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

• ›Adds initiate_chats interface on ConversableAgent for programming a sequence of dependent chats that carry previous chat results forward.
• ›Adds FSM (finite state machine) based group chat via graph group chat support, enabling fine-grained control of speaker order transitions in group chat.
• ›AutoGen Studio gains workflow export, skill editing, and CSV support.
• ›Enables timeout for code execution on Windows using ThreadPoolExecutor.
• ›Every agent in a group chat now receives the termination message, not just the initiating agent.

AutoGen v0.2.10 adds a Custom Model Client API, SocietyOfMindAgent, and tool-overwrite support for GPTAssistantAgent.

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

from autogen import ConversableAgent

class MyCustomClient:
    def create(self, params):
        # call your own model endpoint here
        ...
    def message_retrieval(self, response):
        ...
    def cost(self, response):
        ...
    @staticmethod
    def get_usage(response):
        ...

agent = ConversableAgent(
    name='my_agent',
    llm_config={'model': 'my-model', 'model_client_cls': 'MyCustomClient'},
)
agent.register_model_client(model_client_cls=MyCustomClient)

from autogen.agentchat.contrib.society_of_mind_agent import SocietyOfMindAgent
from autogen import GroupChat, GroupChatManager, AssistantAgent, UserProxyAgent

inner_agents = [AssistantAgent('a1', llm_config=llm_config), AssistantAgent('a2', llm_config=llm_config)]
groupchat = GroupChat(agents=inner_agents, messages=[], max_round=6)
manager = GroupChatManager(groupchat=groupchat, llm_config=llm_config)

society_agent = SocietyOfMindAgent('society', chat_manager=manager, llm_config=llm_config)
user = UserProxyAgent('user', human_input_mode='NEVER')
user.initiate_chat(society_agent, message='Solve this step by step: ...')

• ›Adds GPTAssistantAgent overwrite-tools functionality, letting callers replace the agent's registered tools at runtime.
• ›Adds Custom Model Client support, allowing developers to plug in arbitrary inference backends by implementing a defined client interface.
• ›Adds SocietyOfMindAgent, a new agent class that exposes a single-agent interface while running a full GroupChat as an internal monologue.
• ›Expands token_count_utils with support for new models.

Semantic Kernel 1.4.0 adds audio I/O abstractions, OpenAI File Service, Azure OpenAI Assistants API, and configurable Handlebars Planner prompts.

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

• ›Exposes KernelFunction.ExecutionSettings to IAIServiceSelector, enabling service selectors to inspect per-function execution settings at dispatch time.
• ›Adds Audio-to-Text abstraction and OpenAI implementation for transcribing audio input.
• ›Adds Text-to-Audio abstraction and OpenAI implementation for synthesizing spoken audio from text.
• ›Adds OpenAI File Service support (OpenAI File Service) for uploading and managing files via the OpenAI Files API.
• ›Adds support for the Azure OpenAI Assistants API, enabling Assistants-based workflows in .NET.

Semantic Kernel 1.3.1 adds a Chat Completion Agent, SK Agents framework, work/school account support for Microsoft Graph, and a new OpenApi Extensions project.

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

• ›Adds Functions.OpenApi.Extensions project, extending OpenAPI function support for Semantic Kernel.
• ›Adds ChatCompletionAgent, enabling chat-completion models to be used as first-class agents in .NET.
• ›Adds SK Agents framework, providing a structured foundation for building and composing agents.
• ›Supports work and school accounts in the Microsoft Graph Connector, broadening organizational identity coverage.
• ›Adds PodType.Nano enum value to the Pinecone Connector, enabling use of Pinecone Nano pod types.

Semantic Kernel Python 0.5.1.dev adds CMK support for index creation and Pydantic models for Kernel and KernelFunction.

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

• ›Adds Customer Managed Key (CMK) support to the create Index operation in the Python library.
• ›Converts the Kernel class to a Pydantic model, enabling Pydantic-native validation and serialization of the core kernel object.
• ›Sets default plugins on semantic functions.

Semantic Kernel Python 0.5.0.dev unifies completion responses under KernelContent, adds Astra memory, and overhauls plugin architecture

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

• ›Introduces KernelContent base class that unifies response objects for Chat, Text, and Embedding completions, providing consistent access to response metadata and inner content.
• ›Adds KernelPluginCollection class to replace PluginCollection and ReadOnlyPluginCollection, overhauling the plugin and function architecture.
• ›Renames AIRequestSettings to PromptExecutionSettings to align Python SDK terminology with the .NET implementation.
• ›Adds Astra memory store integration as a new memory backend option.
• ›Drops synchronous function execution — all function invocation is now async-only.

Jan v0.4.6 adds HTTP API model control, factory reset, and a default NGL value for easier local model management.

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

• ›Adds start/stop model via HTTP API, enabling programmatic control of local model lifecycle.
• ›Adds a factory reset feature to restore Jan to a clean default state.
• ›Adds a default value for ngl (GPU layers), reducing manual configuration for new models.
• ›Marks the Jan Data Folder setting as no longer experimental, making it a stable configuration option.
• ›Marks RAG (retrieval-augmented generation) as an experimental feature, surfacing its status in the UI.

KoboldCpp v1.58 adds row-split CUDA multi-GPU mode, AI Vision image interrogation in Lite, and Pygmalion.Chat character imports.

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

$ koboldcpp.exe --usecublas rowsplit --model <model_path>

• ›Adds rowsplit option to --usecublas for row-split mode with CUDA multi-GPU setups; layer split is now the default.
• ›Integrates 'AI Vision' image interrogation in Kobold Lite, using AI Horde or a local A1111 endpoint to let the AI recognize and interpret uploaded or generated images as a multimodal alternative to LLaVA.
• ›Supports importing characters from Pygmalion.Chat in Kobold Lite via the scenarios selector.
• ›Adds an option to run Kobold Lite in the background using a dynamically generated silent audio sound to prevent browser tab hibernation.
• ›Adds an 'Auto' option for idle responses in Kobold Lite.

KoboldCpp v1.57.1 adds --benchmark CSV output, Vulkan multi-GPU via --usevulkan, and smoothing_factor sampling.

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

$ koboldcpp.exe --model mymodel.gguf --usevulkan 0 2 3 --tensor_split 1 1 1

• ›Adds --benchmark flag to run an automated benchmark with current settings, reporting run parameters, timing, and coherence; supply a filename (e.g. --benchmark result.csv) to append results in CSV format.
• ›Adds Vulkan multi-GPU support: specify multiple device IDs with --usevulkan 0 2 3; allocation is controlled by the existing --tensor_split flag (CLI only — GUI launcher does not support multiple Vulkan devices).
• ›Adds temperature Quad-Sampling via the smoothing_factor API parameter, also configurable in the Kobold Lite dynamic temperature panel.
• ›Adds --debugmode timing output in llama.cpp style, measuring only specific eval functions (excluding overhead) alongside display of the seed used.
• ›Adds 'AI Impersonate' feature for Instruct mode in Kobold Lite.

LocalAI v2.8.0 adds Intel GPU support via SYCL container images and drops legacy ggml-based backends.

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

$ docker run -e DEBUG=true -ti -v $PWD/models:/build/models -p 8080:8080 -v /dev/dri:/dev/dri --rm quay.io/go-skynet/local-ai:master-sycl-f32-ffmpeg-core phi-2

• ›Adds Intel GPU support via new container images tagged sycl-f16 and sycl-f32, e.g. quay.io/go-skynet/local-ai:master-sycl-f32-ffmpeg-core, enabling f16 or f32 inference on Intel hardware.
• ›Container images are now based on Ubuntu 22.04 LTS instead of Debian Bullseye.

SGLang v0.1.11 adds LLaVA 1.6, Yi-VL, QWen2 support, faster JSON decoding, flush cache API, and a health endpoint.

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

• ›Adds max_prefill_num_token server argument to control prefill batch size limits.
• ›Adds a flush cache API endpoint to the SGLang runtime server.
• ›Adds a health endpoint to the SGLang runtime server.
• ›Supports specifying all ports in advance via server arguments.
• ›Supports LLaVA v1.6 (including HD variant) and fine-tuned LLaVA model loading.

Adds quadratic sampling and custom sampler order support; llama.cpp multi-GPU now splits by rows instead of layers.

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

• ›Adds custom sampler order support, letting users control the sequence in which samplers are applied during text generation.
• ›Adds quadratic sampling as a new sampling method for text generation.
• ›Splits by rows instead of layers for llama.cpp multi-GPU configurations, improving multi-GPU utilization.
• ›Removes the non-HuggingFace ExLlamaV2 loader, consolidating to the HF-based loader only.

Adds CPU support for Coqui TTS, new Docker GPU options, and a roleplay GBNF grammar file.

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

• ›Adds roleplay.gbnf grammar file for constrained roleplay-format generation.
• ›Adds Docker options for CPU-only, Intel GPU, and AMD GPU deployments.
• ›Enables the Coqui TTS extension to run on CPU, removing the GPU requirement.
• ›Supports running the tool as a git submodule.

vLLM v0.3.1 adds LoRA for Mixtral, InternLM2 support, request-level Prometheus metrics, and ROCm gfx1100 (Radeon 7900) inference.

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

• ›Adds request-level metrics via a refactored Prometheus integration.
• ›Adds LoRA support for Mixtral models.
• ›Adds InternLM2 model support.
• ›Adds a fused top-K softmax kernel for MoE models, improving mixture-of-experts inference efficiency.
• ›Adds support for ROCm on Radeon 7900 series (gfx1100) without requiring flash-attention.

ONNX Runtime v1.17 adds ONNX 1.15 opsets, QNN mixed-precision, WebGPU GA, QLoRA training, and new EP APIs.

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

$ python build.py --config Release --build_shared_lib --enable_lto

• ›Adds AppendExecutionProvider_OpenVINO_V2 API for configuring new OpenVINO EP options.
• ›Adds QNN EP device-level session options soc_model, htp_arch, device_id, extreme_power_saver for htp_performance_mode, and vtcm_mb.
• ›Adds --enable_lto build flag to opt back in to link-time code generation/LTO, which is now disabled by default when building from source.
• ›Adds new dynamic ETW provider for tracing and diagnosing ONNX Runtime internals at runtime with low performance overhead.
• ›Adds support for 12 new ONNX 1.15 opsets: IsInf-20, IsNaN-20, DFT-20, ReduceMax-20, ReduceMin-20, AffineGrid-20, GridSample, ConstantOfShape-20, RegexFullMatch, StringConcat, StringSplit, and ai.onnx.ml.LabelEncoder-4.

Ollama v0.1.26 adds support for bert and nomic-bert embedding models.

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

• ›Supports bert and nomic-bert embedding models.

Ollama v0.1.25 brings native Windows preview with GPU acceleration, full model library access, and OpenAI-compatible API.

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

• ›Setting keep_alive to a negative value (e.g. -1) now keeps a model loaded indefinitely, enabling persistent in-memory model serving.
• ›Ollama is now available natively on Windows (preview), with built-in GPU acceleration, access to the full model library, and the Ollama API including OpenAI compatibility.

Ollama v0.1.24 adds OpenAI Chat Completions API compatibility and the Qwen 1.5 model family.

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

$ curl http://localhost:11434/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "llama2",
        "messages": [
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": "Hello!"}
        ]
    }'

• ›Adds POST /v1/chat/completions endpoint providing initial OpenAI Chat Completions API compatibility, enabling existing OpenAI-compatible clients and SDKs to point at a local Ollama instance without code changes.
• ›Adds Qwen 1.5 model family (qwen) from Alibaba Cloud, spanning 0.5B to 72B parameter sizes, available via the Ollama model library.

Ollama v0.1.23 adds keep_alive API parameter, LLaVA 1.6 vision models, and broader Nvidia GPU support.

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

$ curl http://localhost:11434/api/generate -d '{"model": "mistral", "prompt": "Summarize this document.", "keep_alive": "0"}'

$ curl http://localhost:11434/api/generate -d '{"model": "mistral", "prompt": "Hello", "keep_alive": "-1"}'

• ›Adds keep_alive parameter to the /api/generate (and /api/chat) API to control how long a model stays loaded in memory — accepts positive durations (e.g. 20m, 1hr, 30), 0 to unload immediately, or a negative value (e.g. -1) to keep loaded indefinitely; default is 5 minutes.
• ›Enables passing image paths to ollama run when running multimodal models.
• ›ollama serve now prints the prompt when the OLLAMA_DEBUG=1 environment variable is set.
• ›ollama run now allows sending messages without images to multimodal models.
• ›Updates the LLaVA model family to version 1.6, adding a new llava:34b variant alongside the existing llava (7B) and llava:13b, with support for up to 4x higher image resolution and improved text/chart/diagram reasoning.

Phoenix v3.3.0 adds live span streaming and status descriptions in the trace inspector.

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

• ›Spans now appear in the UI as soon as they arrive, enabling real-time trace visibility without waiting for a trace to complete.
• ›Displays status description text under trace info in the trace detail view, surfacing error and status context inline.

Phoenix v3.2.0 adds log_evaluations to px.Client and displays trace metadata in the UI.

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

import phoenix as px

client = px.Client()
client.log_evaluations(evals_dataframe)

• ›Adds log_evaluations method to px.Client for programmatically uploading evaluation results to a Phoenix server.
• ›Displays span metadata fields in the trace page UI, making trace context visible without leaving the trace view.

Arize Phoenix v3.1.0 adds metadata-value filtering for spans in the trace UI.

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

• ›Enables filtering spans by metadata values in the trace explorer.

Phoenix v3.0.0 replaces its own tracers with OpenInference instrumentors for LLM observability.

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

• ›Replaces Phoenix-native tracers with OpenInference instrumentors for tracing LLM applications.

Phoenix v2.11.0 adds an hour-level time range option to the UI for finer trace inspection.

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

• ›Adds an hour time range selector to the UI, enabling finer-grained filtering of traces and spans.

Arize Phoenix v2.10.0 adds search by text and ID in the embeddings selection view.

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

• ›Adds search by text and ID on selection in the embeddings view.

Phoenix client gains four new data-retrieval methods for spans, traces, and evaluations.

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

import phoenix as px

client = px.Client()
evaluations = client.get_evaluations()
print(evaluations)

import phoenix as px

client = px.Client()
df = client.get_spans_dataframe()
print(df.head())

• ›Adds get_evaluations() and get_trace_dataset() methods to the Phoenix client for programmatic retrieval of evaluation results and trace datasets.
• ›Adds get_spans_dataframe() and query_spans() methods to the Phoenix client for querying and retrieving spans as a dataframe.

Langfuse v2.8.0 adds a dedicated GET /score/{scoreId} endpoint and a JSON editor for dataset items.

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

$ curl -X GET 'https://<your-langfuse-host>/api/public/score/<scoreId>' \
  -H 'Authorization: Bearer <secret-key>'

• ›Adds GET /score/{scoreId} API endpoint to retrieve individual scores by ID.
• ›New JSON editor for dataset items in the UI, replacing the previous plain-text input.

Langfuse v2.7.0 adds htmlPath and totalCost to the trace API and introduces prompt config support.

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

$ curl -u <public_key>:<secret_key> https://cloud.langfuse.com/api/public/traces/<trace_id> | jq '{totalCost: .totalCost, htmlPath: .htmlPath}'

• ›Adds htmlPath and totalCost fields to the GET /traces/{id} API response, enabling cost retrieval and direct UI deep-linking per trace.
• ›Adds prompt config support, allowing configuration to be attached to prompts.

Langfuse v2.6.0 adds score deletion, a daily metrics endpoint, richer trace fields, and OpenAI function-call previews in the UI.

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

$ curl -X DELETE https://<your-langfuse-host>/api/public/score/<scoreId> \
  -H 'Authorization: Bearer <secret-key>'

$ curl -X GET 'https://<your-langfuse-host>/api/public/metrics/daily' \
  -H 'Authorization: Bearer <secret-key>'

$ curl -X GET 'https://<your-langfuse-host>/api/public/traces?limit=50' \
  -H 'Authorization: Bearer <secret-key>'

• ›Adds DELETE /api/public/score/[scoreId] endpoint to programmatically delete individual scores.
• ›Adds GET /api/public/metrics/daily endpoint for retrieving daily usage metrics.
• ›Adds htmlPath, latency, and totalCost fields to GET /api/public/traces responses.
• ›Adds traces filter to the dashboard UI for narrowing displayed data.
• ›Adds preview rendering of OpenAI function calls in the UI.

Langfuse v2.5.1 lets you supply an explicit timestamp when creating a trace via the API.

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

• ›Adds optional timestamp field to the create-trace API endpoint, enabling callers to set an explicit timestamp rather than accepting a server-generated one.

Langfuse v2.5.0 adds latency data to the generations API endpoints.

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

• ›Adds latency field to generations API endpoints, enabling programmatic latency analysis on generation data.

Langfuse v2.4.1 adds audit logging and updated OpenAI pricing data.

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

• ›Adds audit logging to track security-relevant actions across the platform.
• ›Updates OpenAI model pricing data for more accurate cost tracking.

Langfuse v2.4.0 adds collapsible/color-coded trace trees and prompt deletion with variable deduplication.

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

• ›Adds collapse/expand controls and color coding by observation type to the trace view observation tree in the UI.
• ›Adds the ability to delete prompts and individual prompt versions, and deduplicates prompt variables in the prompt editor.

Langfuse v2.3.0 adds in-product feature notifications, quickstart examples on API key creation, and a dashboard request button.

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

• ›Adds quickstart examples directly in the API key creation popup to help new users get started faster.
• ›Adds in-product notifications to surface new features to users without leaving the UI.
• ›Adds a 'Request Dashboard' button in the UI for users to submit dashboard feature requests.

Langfuse v2.2.0 adds score name selection in dashboard charts and expands generation model units.

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

• ›Dashboard charts now support interactive selection of score names in the legend and a slider for filtering, enabling more focused LLM evaluation views.
• ›Expands the unit types tracked for generation models, broadening cost and usage measurement coverage.

Langfuse v2.1.0 adds custom regex matching and unrestricted pricing for user-defined models.

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

• ›Supports custom regex patterns for matching user-defined models, enabling flexible model name recognition beyond built-in presets.
• ›Allows setting input, output, and total price for user-defined models without restrictions, enabling accurate cost tracking for any custom or private model.

Langfuse v2.0.1 adds built-in model definitions for OpenAI fine-tuned and Vertex AI models.

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

• ›Adds support for OpenAI fine-tuned and Vertex AI models in the model catalog for cost and usage tracking.

Chroma 0.4.23 adds Amazon Bedrock embeddings, SSL client verification, FIPS compliance, CLI log path support, and a Rust-based worker backend.

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

• ›Adds [ENH][SEC]: CIP-01022024 SSL Verify Client Config — TLS client certificate verification support for the Chroma server.
• ›Adds [ENH]: CLI log path parameter support — a new CLI parameter to control the log output path.
• ›Adds Amazon Bedrock embedding function, enabling use of AWS Bedrock models for embedding generation.
• ›Adds FIPS compliance mode to the Python client.
• ›Adds exponential backoff with jitter to embedding API calls, reducing failures under rate limits.

LanceDB python-v0.6.0 adds column management APIs and an async Python client.

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

table.drop_columns(["embedding"])

• ›Adds add_columns, alter_columns, and drop_columns APIs for programmatic schema management on tables.
• ›Introduces a basic async Python client as a new starting point for async workflows.

LanceDB v0.4.11 adds ImageBind embeddings, a batch-request threadpool, and read-consistency control for Node/Rust.

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

• ›Adds read_consistency_interval configuration to the Node and Rust clients, enabling control over read consistency for distributed/cloud-backed tables.
• ›Adds an optional threadpool for batch embedding requests in the Python client, improving throughput for bulk vectorization workloads.
• ›Adds ImageBind embedding function support in the Python client, enabling multimodal (image, text, audio, etc.) embeddings natively in LanceDB.

LanceDB python-v0.5.7 adds ImageBind embedding function support.

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

• ›Adds ImageBind embedding function support for multimodal vector generation.

LanceDB python-v0.5.6 adds an optional threadpool for batch requests.

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

• ›Adds an optional threadpool for batch requests to improve throughput on concurrent workloads.

LanceDB v0.4.10 makes it easier to create empty tables and makes the vector column optional.

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

• ›Simplifies creation of empty tables without requiring upfront data.
• ›Makes the vector column optional when creating tables.

LanceDB python-v0.5.5 makes the vector column optional and ships hybrid search updates with latency benchmarks.

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

• ›Makes the vector column optional when creating or querying tables, enabling use cases where vector embeddings are not required.
• ›Updates hybrid search with new examples and latency benchmarks to support performance-aware retrieval workflows.

LanceDB v0.4.9 adds filterable count_rows across all APIs and filter support during merge-insert match conditions.

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

• ›Adds count_rows with filter support to all LanceDB APIs, enabling row counts scoped to a predicate.
• ›Adds filter support for the 'when matched' branch of merge insert operations across all LanceDB APIs.

LanceDB python-v0.5.4 adds new OpenAI embedding functions, read consistency control, filterable row counts, and merge-insert match filtering.

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

import lancedb

db = lancedb.connect(
    "s3://my-bucket/lancedb",
    read_consistency_interval=5  # seconds
)
table = db.open_table("my_table")

import lancedb

db = lancedb.connect("~/.lancedb")
table = db.open_table("my_table")
count = table.count_rows(filter="category = 'critical'")
print(count)

• ›Adds read_consistency_interval argument to control read consistency for LanceDB connections.
• ›Adds filterable count_rows to all LanceDB APIs, enabling row counts with predicate pushdown.
• ›Adds support for filter conditions during merge_insert when rows are matched, enabling conditional upsert logic.
• ›Adds support for new OpenAI embedding functions in the Python embedding function registry.
• ›Improves Reranker developer experience with DX improvements to the reranker API.

LanceDB v0.4.8 adds merge_insert to the Node.js and Rust APIs for upsert-style table operations.

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

• ›Adds merge_insert to the Node.js and Rust APIs, enabling upsert-style (merge/insert) operations on LanceDB tables.

LanceDB python-v0.5.2 adds hybrid search, AWS Bedrock embeddings, merge_insert, and a reworked Node.js SDK via NAPI

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

results = (
    table.search("your query", query_type="hybrid")
    .rerank(reranker=reranker)
    .limit(10)
    .to_pandas()
)

from lancedb.embeddings import get_registry

bedrock = get_registry().get("bedrock").create()

class MyTable(LanceModel):
    text: str = bedrock.SourceField()
    vector: Vector(bedrock.ndims()) = bedrock.VectorField()

• ›Adds a Hybrid Search and Reranker API to the Python SDK for combining vector and scalar search results.
• ›Adds AWS Bedrock embeddings integration to the Python embedding functions.
• ›Adds gte-mlx/gte-large embedding function support to the Python SDK.
• ›Adds connect and connect_with_options functions to the Rust SDK.
• ›Reworks the Node.js SDK using NAPI, providing a new createIndex API and query issuing capability.