The AI Toolchain — issue -386, September 30, 2023

Aider v0.14.0 adds Claude 2 and multi-LLM support via OpenRouter and requires Python 3.9+.

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

• ›Adds support for Claude 2 and other LLMs through OpenRouter integration, expanding beyond OpenAI models.
• ›Publishes documentation for running the aider benchmarking suite.

Zed v0.104.4 adds buffer search-and-replace, Nushell syntax highlighting, and expanded Vim command support.

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

• ›Adds 'replace' functionality to buffer search.
• ›Adds syntax highlighting for Nushell script files.
• ›Adds Vim g s / g S bindings to show symbols in the current buffer or workspace.
• ›Adds Vim ZZ and ZQ bindings to close the current item.
• ›Adds Vim support for counts with insert actions (2i, 2o, 2a, etc.).

Zed v0.103.1 adds Tailwind CSS autocomplete, a CSS language server, and Vim S substitute-line support.

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

• ›Adds Vim S command to substitute the current line.
• ›Adds basic Tailwind CSS autocomplete support.
• ›Adds a CSS language server providing autocomplete and linting.

Zed v0.102.1 adds Inline Assist AI code generation, dynamic inlay hints, relative line numbers, and Python venv auto-activation in the terminal.

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

• ›Adds ctrl-enter keybinding to trigger the new 'Inline Assist' feature, allowing AI-powered transformation of a selection or code generation at the cursor.
• ›Adds "ctrl-shift-:": "editor::ToggleInlayHints" as a default key binding to toggle inlay hints.
• ›Adds relative_line_numbers setting to enable relative line number display in the editor.
• ›Adds detect_venv setting for the terminal to automatically activate Python virtual environments on terminal creation.
• ›Adds support for dynamic inlay hints, enabling LSP servers to provide hints that update as code changes.

Haystack v1.20.0 adds LostInTheMiddleRanker, DiversityRanker, allowed_domains for WebRetriever, and dynamic filter support in custom OpenSearch/Elasticsearch queries.

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

from haystack.nodes import WebRetriever, TopPSampler, DiversityRanker, LostInTheMiddleRanker
from haystack.pipelines import Pipeline

web_retriever = WebRetriever(api_key=search_key, top_search_results=5, mode="preprocessed_documents", top_k=50)
sampler = TopPSampler(top_p=0.97)
diversity_ranker = DiversityRanker()
litm_ranker = LostInTheMiddleRanker(word_count_threshold=1024)

pipeline = Pipeline()
pipeline.add_node(component=web_retriever, name="Retriever", inputs=["Query"])
pipeline.add_node(component=sampler, name="Sampler", inputs=["Retriever"])
pipeline.add_node(component=diversity_ranker, name="DiversityRanker", inputs=["Sampler"])
pipeline.add_node(component=litm_ranker, name="LostInTheMiddleRanker", inputs=["DiversityRanker"])
pipeline.add_node(component=prompt_node, name="PromptNode", inputs=["LostInTheMiddleRanker"])

retriever = BM25Retriever(
    custom_query="""
    {
        "query": {
            "bool": {
                "should": [{"multi_match": {
                    "query": ${query},
                    "type": "most_fields",
                    "fields": ["content", "title"]}}],
                "filter": ${filters}
            }
        }
    }"""
)

retriever.retrieve(
    query="What is the meaning of life?",
    filters={"year": [2019, 2020], "quarter": [1, 2, 3], "date": {"$gte": "2019-03-01"}}
)

web_retriever = WebRetriever(
    api_key=search_key,
    allowed_domains=["docs.haystack.deepset.ai", "haystack.deepset.ai"],
    top_search_results=10,
    mode="preprocessed_documents"
)

• ›Adds LostInTheMiddleRanker class, which reorders documents so the most relevant appear at the beginning and end of the context window, implementing the 'Lost in the Middle' strategy for RAG pipelines; accepts a word_count_threshold parameter.
• ›Adds DiversityRanker class, which uses sentence-transformer models to rank documents so each successive result is maximally semantically dissimilar from already-selected ones; accepts a top_k parameter.
• ›Adds ${filters} placeholder support in custom_query for BM25Retriever with OpenSearch and Elasticsearch, enabling dynamic query-time filters without modifying the stored query template.
• ›Adds allowed_domains parameter to WebRetriever, enabling domain-scoped searches for 'talk to a website' and 'talk to docs' use cases.
• ›Adds search_fields parameter to DeepsetCloudDocumentStore sparse queries, allowing BM25Retriever to search meta fields such as title alongside document content.

LangChain v0.0.304 adds exact-match and regex evaluators, extra tools for pandas agent, arxiv ID support, and Claude/Bedrock prompt wrapping.

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

• ›Adds extra_tools argument to the pandas agent toolkit, allowing practitioners to inject additional tools into the agent at construction time.
• ›Adds ExactMatchEvaluator and RegexMatchEvaluator evaluators for deterministic, code-based evaluation of LLM outputs without requiring an LLM judge.
• ›Adds prompt wrapping for Claude when using the Bedrock integration, ensuring Claude-formatted human/assistant turns are applied automatically.
• ›Adds support for arxiv identifier lookups in ArxivAPIWrapper(), enabling direct paper retrieval by arxiv ID in addition to keyword search.
• ›Adds support for stop sequences in the Fireworks LLM integration.

LangChain v0.0.303 adds ChatFireworks support, custom bulk args for ElasticsearchStore, and an improved pairwise comparison chain.

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

• ›Adds ChatFireworks chat model integration and refactors the Fireworks provider.
• ›Enables custom bulk arguments on ElasticsearchStore for tuning indexing behavior.
• ›Makes the pairwise comparison chain more aligned with the LLM-as-a-judge evaluation pattern.

LangChain v0.0.302 adds Kay retriever, graph schema filtering for Cypher generation, and batching for HuggingFace pipelines.

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

• ›Adds Kay retriever for retrieving structured data via the Kay API.
• ›Adds schema filtering for graph-based Cypher generation, letting the LLM work with a scoped subset of the graph schema.
• ›Adds batching support for hf_pipeline (HuggingFace pipeline) inference.

LangChain v0.0.301 adds Gradient.ai and LLMRails embeddings and expands OpenSearch vector store capabilities.

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

• ›Adds from_texts and add_texts support for passing ids and indexname in the OpenSearch vector store integration.
• ›Adds Gradient.ai embedding integration.
• ›Adds LLMRails embedding integration.

LangChain v0.0.300 adds async support to multi-query and merger retrievers, plus run naming for non-chain runs.

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

• ›Adds async support to MultiQueryRetriever, enabling non-blocking parallel query generation and retrieval.
• ›MergerRetriever now calls all retrievers concurrently in its async path, reducing latency when combining multiple retrieval sources.
• ›Accepts a run_name argument for non-chain runs (tools, retrievers, etc.), surfacing meaningful labels in run traces.

LangChain v0.0.299 adds Runnable.astream_log() for async streaming with intermediate run state.

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

async for chunk in chain.astream_log(input):
    print(chunk)

• ›Adds Runnable.astream_log() method for async streaming that also yields intermediate log entries from a run.
• ›Separates base URL from loaded URL in sub-link extraction, enabling finer control over crawl scope.

LangChain v0.0.298 adds Javelin, Gradient.ai LLM, and Timescale Vector (Postgres) integrations.

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

• ›Adds Gradient.ai LLM integration, enabling use of Gradient-hosted models as a LangChain LLM provider.
• ›Adds Timescale Vector (Postgres) integration as a new vector store backend.
• ›Adds Javelin integration as a new provider.

LangChain v0.0.297 adds streaming for Vertex AI and Amazon Bedrock, plus new agent output parsers.

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

• ›Adds streaming support for Amazon Bedrock LLMs.
• ›Adds streaming support for Vertex AI via stream refactor.
• ›Adds agent output parsers for structured agent response handling.
• ›Improves criteria parser for evaluation chains.
• ›Adds formatting of intermediate steps in agent execution.

LangChain v0.0.296 adds Remembrall integration, XMLOutputParser, synthetic data generation, Vald/LLMRails/Minimax/Vearch vector stores, and HTTP PUT support in OpenAPI agent.

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

from langchain.output_parsers import XMLOutputParser

parser = XMLOutputParser()
chain = prompt | llm | parser
result = chain.invoke({"input": "List three CVEs in XML format"})

from langchain.retrievers import PineconeHybridSearchRetriever

retriever = PineconeHybridSearchRetriever(
    index=index,
    embeddings=embeddings,
    sparse_encoder=sparse_encoder,
    namespace="tenant-acme"
)
results = retriever.get_relevant_documents("SQL injection techniques")

• ›Adds namespace parameter to Pinecone hybrid search, enabling namespace-scoped similarity queries.
• ›Adds batch_size parameter to Weaviate vector store for controlling ingestion throughput.
• ›Adds XMLOutputParser for parsing LLM outputs structured as XML.
• ›Expands WeaviateHybridSearchRetriever to accept additional keyword arguments, enabling finer search control.
• ›Adds support for HTTP PUT in the OpenAPI agent prompt, extending the set of REST methods the agent can use.

LangChain v0.0.295 adds extra-variable support in prompt templates, config metadata merging, and cross-account SageMaker boto3 injection.

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

• ›Allows extra variables to be passed when invoking prompt templates without raising an error, enabling more flexible template reuse.
• ›Merges metadata and tags supplied in config objects, so both sources are preserved rather than one overwriting the other.
• ›Adds ability to inject a custom boto3 client into the SageMaker endpoint integration to support cross-account inference scenarios.

LangChain v0.0.294 adds support for GPT-3.5-turbo-instruct models in the OpenAI LLM class.

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

• ›Supports gpt-3.5-turbo-instruct models in the OpenAI LLM class, enabling use of instruct-tuned variants alongside existing OpenAI completions models.

LangChain v0.0.293 adds RunnableBranch, kwargs support in RunnableWithFallbacks, and llm_kwargs for Xinference LLMs

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

from langchain.schema.runnable import RunnableBranch

branch = RunnableBranch(
    (lambda x: x['topic'] == 'sql', sql_chain),
    (lambda x: x['topic'] == 'code', code_chain),
    general_chain
)
branch.invoke({'topic': 'sql', 'question': 'How do I join two tables?'})

• ›Adds RunnableBranch class for conditional branching logic within LCEL chains.
• ›Adds llm_kwargs parameter to Xinference LLMs for passing additional keyword arguments to the underlying model.
• ›Adds kwargs support in RunnableWithFallbacks, enabling fallback chains to receive arbitrary keyword arguments.
• ›Adds IO visibility for chain groups, supporting showing inputs and outputs within a chain group.

LangChain v0.0.292 adds Ollama embeddings support and streaming transform methods for runnable sequences.

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

• ›Adds transform and atransform support to runnable sequences, enabling streaming/async streaming through RunnableSequence pipelines.
• ›Adds embeddings support for Ollama, allowing local model embeddings via the Ollama integration.

LangChain v0.0.289 adds Baidu Qianfan LLM, Replicate streaming, Neo4j hybrid search, Redis MMR retrieval, and Cassandra metadata filtering.

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

• ›Adds Baidu Qianfan endpoint as a new LLM integration.
• ›Adds streaming support for the Replicate LLM integration.
• ›Adds MMR (maximal marginal relevance) support to the Redis retriever.
• ›Adds hybrid search to the Neo4j vector index.
• ›Adds metadata filtering to the Cassandra Vector Store.

LangChain v0.0.288 adds ElevenLabs text-to-speech integration and average feedback aggregation.

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

• ›Adds ElevenLabs text-to-speech integration, enabling audio synthesis from LangChain pipelines.
• ›Adds average feedback aggregation support.

LangChain v0.0.287 adds a Prompt Injection Identifier, GitLab toolkit, file-like object support in the CSV Agent, and a custom Ernie API base.

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

• ›Adds support for a custom ernie_api_base configuration in the Ernie LLM integration.
• ›Adds a Prompt Injection Identifier to detect prompt injection attempts in inputs.
• ›Adds a GitLab toolkit and companion notebook for GitLab-based agent workflows.
• ›Adds file-like object support in the CSV Agent Toolkit, enabling in-memory or streamed CSV sources instead of only file paths.

LangChain v0.0.286 adds KonkoAI chat model, Ctranslate2 LLM, Vearch vectorstore, MMR search for Redis and PGVector, and a Runnable-powered agent.

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

• ›Adds where_document filter parameter to Chroma vector store queries for document-level filtering.
• ›Adds language parameter to the NLTK text splitter to support multilingual tokenization.
• ›Adds ernie_api_base custom endpoint support and async methods to ErnieEmbeddings.
• ›Adds Maximal Marginal Relevance (MMR) search support to the Redis vector store.
• ›Adds Maximal Marginal Relevance (MMR) search support to the PGVector vector store.

LangChain v0.0.285 adds self-querying retrievers for Vectara and Supabase, multilingual anonymization, and a boto3_session parameter for cross-account DynamoDB.

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

• ›Adds boto3_session parameter to the AWS DynamoDB integration to support cross-account use cases.
• ›Adds self-querying retriever support for Vectara vector store.
• ›Adds self-querying retriever support for Supabase vector store.
• ›Adds multilingual anonymization capability to the anonymization module.
• ›Adds a progress bar to the evaluation runner.

LangChain v0.0.284 adds NucliaDB vector store, Diffbot Graph Transformer, data deanonymization, and Hugging Face Inference API embeddings.

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

• ›Adds NucliaDB vector store integration for storing and querying embeddings via NucliaDB.
• ›Adds DiffbotGraphTransformer for extracting knowledge graphs from text and ingesting them into Neo4j graph documents.
• ›Adds data deanonymization support, enabling pipelines to reverse anonymization on LLM outputs.
• ›Adds Hugging Face Inference API as an embeddings backend, allowing document embedding without a locally downloaded model.
• ›Adds sqlite-vss as a supported vector store backend.

LangChain v0.0.283 adds a VLLM download_dir argument, custom SQL Agent tools, and NumberedListOutputParser.

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

from langchain.llms import VLLM

llm = VLLM(
    model="mistralai/Mistral-7B-v0.1",
    download_dir="/mnt/model-cache"
)

• ›Adds download_dir argument to the VLLM integration, letting callers specify where model files are stored locally.
• ›Exposes NumberedListOutputParser via the output_parser init, making it importable from the top-level parsers module.
• ›Supports adding custom tools to the SQL Agent, extending its default toolset with user-defined functions.
• ›Allows None as a valid temperature value in the TGI (Text Generation Inference) LLM integration.

LangChain v0.0.281 adds Bedrock Claude chat, Azure Document Intelligence, Cassandra LLM cache, FalkorDB, and more new integrations.

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

results = db.similarity_search_with_score(query, where_filter={"path": ["category"], "operator": "Equal", "valueText": "finance"})

from langchain.cache import CassandraSemanticCache
import langchain
langchain.llm_cache = CassandraSemanticCache(session=session, keyspace="langchain", embedding=embeddings)

• ›Adds AzureAIDocumentIntelligenceParser and AzureAIDocumentIntelligenceLoader for parsing and loading documents via Azure Document Intelligence service.
• ›Adds where filter parameter to Weaviate similarity search with score, enabling filtered vector queries.
• ›Adds ne (not-equal) comparator for self-query retrievers.
• ›Adds model_kwargs parameter to HuggingFace TGI (langchain.llms HF text-generation-inference) for passing arbitrary inference parameters.
• ›Allows specifying arbitrary keyword arguments in langchain.llms.VLLM.

LangChain v0.0.279 adds async tool support, Runnable retry/config methods, ApifyWrapper, EdenAI tools, and sqlite-vss vector store.

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

chain.with_config({"run_name": "my-audit-chain", "run_id": "abc-123"}).invoke({"input": "What are the open CVEs?"})

• ›Adds .with_config() method to Runnables, plus run_id and run_name fields to RunnableConfig, enabling per-run identification and configuration.
• ›Adds ApifyWrapper class for integrating Apify web-scraping actors into chains.
• ›Adds async support for tools, enabling non-blocking tool execution in async chains.
• ›Adds EdenAI tools integration for AI-powered third-party services.
• ›Adds sqlite-vss as a supported vector store backend.

AutoGen v0.1.2 adds single-line code detection and new RetrieveChat controls including customized_answer_prefix and no_update_context.

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

• ›Adds customized_answer_prefix parameter to RetrieveChat to trigger Update Context when the specified prefix is absent from the answer, enabling custom trigger-word control.
• ›Adds no_update_context parameter to RetrieveChat to suppress Update Context entirely.
• ›Extends extract_code to detect single-line code blocks.
• ›RetrieveChat now upserts to ChromaDB in batches of 40,000 records, improving stability for large corpora.

Semantic Kernel Python gains a Redis memory connector and chat system message support in completion settings.

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

• ›Adds Redis memory connector, enabling Redis as a vector/memory backend for Semantic Kernel Python applications.
• ›Adds chat_system_message to completion settings, allowing a system prompt to be set for chat-based LLM calls.
• ›Adds a settings function to load configuration directly into the constructor, streamlining kernel initialization.

KoboldCpp v1.43 adds automatic RoPE scale calculation, older GGML support, and thread-safe SSE streaming improvements.

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

• ›Adds automatic RoPE scale calculation based on a model's training context (n_ctx_train) when --ropeconfig is not explicitly set; --ropeconfig overrides this behavior.
• ›Tweaks --unbantokens to push banned token logit values further down, reducing rare appearances while avoiding -inf to preserve sampling compatibility.
• ›Adds support for older GGML format (ggjt_v3) for 34B LLaMA 2 models (note: may have issues when n_gqa is not 1; GGUF recommended in that case).
• ›Adds mutex for thread-safe polled-streaming, enabling safer concurrent SSE stream consumption.
• ›Integrates SSE streaming improvements for more reliable server-sent event delivery.

oobabooga textgen v1.6 adds GGUF support, ExLlamaV2 loaders, CFG sampling, SSL, named Cloudflare tunnels, and a logit viewer.

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

• ›Adds --cpu option for llama.cpp to force CPU-only inference and prevent CUDA from being used.
• ›Adds --disable_exllama option for AutoGPTQ to bypass ExLlama kernels.
• ›Adds auto_max_new_tokens parameter to automatically size the maximum new tokens based on context.
• ›Adds max_tokens_second parameter to rate-limit token generation speed.
• ›Adds SSL certificate support for securing the web UI endpoint.

vLLM v0.1.6 reverts a breaking API change and delivers faster startup plus background task generation.

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

• ›Reduces vLLM startup time for faster engine initialization.
• ›Starts background tasks within AsyncLLMEngine.generate so generation can proceed asynchronously without requiring a separate task launch.

vLLM v0.1.5 adds CodeLlama support, safetensors loading for all models, and OpenAPI request body specs for OpenAI endpoints.

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

• ›Enables safetensors loading for all models, expanding the supported weight formats beyond the previous subset.
• ›Adds support for CodeLlama, expanding the roster of served models.
• ›Enables request body OpenAPI spec for OpenAI-compatible endpoints, making the API surface formally documented and machine-readable.
• ›Stabilizes AsyncLLMEngine with a background engine loop, making async serving more robust for production use.
• ›Aligns beam search implementation with HuggingFace hf_model.generate, improving output consistency for beam-search workloads.

Ollama v0.0.20 adds IPv6 support, auto-pull on remote, faster model loading, and a Python client library.

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

$ curl http://<host>:11434/api/generate -d '{"model": "llama2", "prompt": ""}'

• ›Adds api/client.py, a Python client library for accessing Ollama programmatically.
• ›OLLAMA_HOST now accepts IPv6 hostnames.
• ›Sending an empty prompt field to /api/generate pre-loads the model so the next request is faster.
• ›ollama run now loads models immediately on startup, reducing latency even on the first prompt.
• ›ollama run automatically pulls models that don't exist when connected to a remote Ollama instance.

Ollama v0.0.19 adds GGUF model import support and automatic local data cleanup.

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

• ›Supports importing and running GGUF file type models locally.
• ›Automatically cleans up unused local model data.
• ›Updated Docker image available via docker pull ollama/ollama.

Ollama v0.0.18 adds ollama show command to inspect model system prompts, parameters, templates, and Modelfiles.

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

$ ollama show --system orca-mini
ollama show --parameters codellama
ollama show --template llama2
ollama show --modelfile llama2

• ›New ollama show command with --system, --parameters, --template, and --modelfile flags to inspect a model's system prompt, parameters, default prompt template, and Modelfile respectively.
• ›Adds a new sentiments example contributed by @technovangelist.
• ›Building from source now requires running go generate ./... to generate dependencies, with cmake as a new build prerequisite.

Phoenix v0.0.41 adds document metadata visibility in the trace view.

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

• ›Displays document metadata in the trace UI, giving practitioners direct visibility into retrieval context during trace inspection.

Phoenix v0.0.40 adds templating semantic conventions for LLM spans and a LangChainInstrumentor for nested chains.

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

from phoenix.trace.langchain import LangChainInstrumentor

LangChainInstrumentor().instrument()

• ›Adds LangChainInstrumentor for tracing nested LangChain chains as structured spans.
• ›Adds templating semantic conventions to LLM spans, enabling structured capture of prompt template metadata.

Phoenix v0.0.39 adds VertexAI model support, new LLM message attributes, and error handling for llama-index traces.

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

• ›Adds LLM_OUTPUT_MESSAGES attribute and renames LLM_MESSAGES to LLM_INPUT_MESSAGES to distinguish input and output message spans.
• ›Adds VertexAI model implementation for use as an evaluation model.
• ›Adds error handling attributes for llama-index instrumentation.
• ›Displays total token count in the trace page header.

Phoenix v0.0.38 adds LangChain LLM message attributes, agent span kind for LangChain, and slow-span highlighting in the tracing UI.

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

• ›Adds agent span kind classification for LangChain traces, surfacing agent-type spans distinctly in the tracing view.
• ›Captures LangChain LLM message attributes in trace spans, giving practitioners visibility into the full message structure exchanged with LLMs.
• ›Highlights slow spans in the tracing UI to make latency outliers immediately visible during trace inspection.
• ›Makes trace rows clickable in the tracing UI for faster drill-down into individual span details.

Phoenix v0.0.37 adds LangChain prompt semantic conventions, a tool details UI panel, and a prompts list view, plus moves tracing out of experimental.

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

• ›Adds LangChain LLM prompts semantic convention support for richer span attribution in LangChain traces.
• ›New tool details UI panel surfaces tool call information directly in the tracing interface.
• ›New prompts list view in the UI lets practitioners browse and inspect captured prompts.
• ›Tracing is promoted out of experimental status, signaling production readiness.

Phoenix v0.0.33 ships full LLM tracing with LangChain/LlamaIndex callbacks, binary evals, hallucination detection, and a rich spans/traces UI.

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

from phoenix.trace.trace_dataset import TraceDataset

dataset = TraceDataset.from_spans(spans)

• ›Adds host parameter to launch_app for controlling the bind address when starting the Phoenix server.
• ›Adds TraceDataset.from_spans class method to construct a dataset directly from collected spans.
• ›Adds run_eval function for running evaluations against a dataset.
• ›Adds llm_eval_binary function for binary (pass/fail) LLM evaluations using an OpenAI model.
• ›Adds hallucination eval capability via a new dedicated eval type.

Chroma 0.4.10 adds auth and external volume support for GCP deployments.

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

• ›Adds authentication and external volume support for GCP deployments.
• ›Publishes official Docker images to DockerHub at chromadb/chroma:0.4.10 in addition to the existing GitHub Container Registry image.

Chroma 0.4.9 adds collection filtering, $in/$nin metadata operators, JS auth, and AWS deployment support.

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

collection.query(
    query_texts=["security vulnerabilities"],
    where={"category": {"$in": ["cve", "advisory", "patch"]}},
    n_results=10
)

collection.query(
    query_texts=["malware behavior"],
    where={"source": {"$nin": ["unverified", "draft"]}},
    n_results=10
)

• ›Adds $in and $nin metadata filter operators (CIP-4) so queries can match documents where a field's value is in or not in a given list.
• ›Adds collection-level filtering (CIP-1), allowing clients to filter the list of collections returned.
• ›Adds authentication support to the JavaScript client, bringing JS client auth parity with the Python client.
• ›Adds ONNX runtime session providers, enabling hardware-accelerated inference backends for embedding functions.
• ›Adds AWS deployment support for self-hosting Chroma on AWS infrastructure.

LanceDB v0.2.6 adds multi-modal embedding functions and a lancedb.__version__ attribute.

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

import lancedb
print(lancedb.__version__)

• ›Adds lancedb.__version__ attribute for programmatic version introspection.
• ›Introduces multi-modal embedding function support, enabling embedding pipelines that handle more than one data modality.
• ›Improves Pydantic 1.x compatibility for schema definitions.

LanceDB python-v0.2.4 adds pydantic-backed embedding function persistence, temporary table updates, and URI query string propagation to Lance.

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

• ›Adds pydantic-based persistence for embedding functions, enabling embedding configurations to be saved and restored reliably.
• ›Supports default values on pydantic vector fields, allowing model definitions to omit explicit vector initialization.
• ›Adds temporary update feature for Python tables, enabling in-place modifications without committing a permanent write.
• ›Propagates URI query string parameters through to the underlying Lance storage layer, unlocking AWS-specific storage options via connection strings.

LanceDB v0.2.5 adds schema evolution, temporary updates, and pydantic embedding persistence for local Python tables.

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

• ›Supports schema evolution in local LanceDB Python tables, allowing columns to be added or changed without recreating the table.
• ›Adds temporary update feature for Python, enabling in-place row modifications that can be staged before committing.
• ›Uses Pydantic for embedding function persistence, allowing embedding configurations to be serialized and reloaded reliably.
• ›Supports Pydantic vector fields with default values, reducing boilerplate when defining vector schemas.
• ›Propagates URI query strings through to Lance, enabling AWS-specific connection parameters to be passed via the connection URI.

Qdrant v1.5.0 adds binary quantization, batch point updates, shard snapshot API, and Kubernetes health endpoints.

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

$ curl -X POST 'http://localhost:6333/collections/my_collection/points/search' \
  -H 'Content-Type: application/json' \
  -d '{
    "vector": [0.1, 0.2, 0.3],
    "limit": 10,
    "params": {
      "indexed_only": true
    }
  }'

$ curl -X POST 'http://localhost:6333/collections/my_collection/shards/0/snapshots'

$ curl -f http://localhost:6333/readyz

• ›Adds indexed_only parameter to search requests to skip unindexed segments, speeding up search over large collections.
• ›Adds a batch update endpoint for the points API, enabling multiple point operations in a single request.
• ›Adds binary quantization support as a new quantization method for vector compression.
• ›Adds shard snapshot API for creating and managing per-shard snapshots in distributed deployments.
• ›Adds healthz, livez, and readyz HTTP endpoints for standard Kubernetes liveness and readiness health checking.