langchain-ai/langchain

This system is a modular framework for building and managing AI applications, centered on a core library that defines standard abstractions for chat models, tools, and document processing. It provides a unified interface for integrating with numerous external providers, including OpenAI, Anthropic, and Hugging Face, while enforcing security and performance standards through middleware and strict serialization controls. The platform supports the construction of complex agent workflows via a declarative expression language and offers specialized utilities for vector storage, indexing, and structured output parsing.

97 changes.

The project underwent a major architectural overhaul, introducing \langchain-core\ as a foundational library with the LangChain Expression Language (LCEL) and lazy-loading optimizations. Legacy modules and examples were removed to support a new monorepo structure, while \langchain-classic\ was established to maintain backward compatibility for deprecated features. This period focused on stabilizing the new abstractions, enforcing strict import hygiene, and expanding test coverage across core components and partner integrations.

70 changes.

This period focused on expanding the partner ecosystem with initial releases for Exa, Nomic, Hugging Face, and xAI, while updating existing integrations like OpenAI, Groq, and Qdrant to support new SDKs and APIs. Concurrently, significant core refactoring occurred, including the decoupling of text splitters, the introduction of a standard VectorStore abstraction, and the establishment of a unified testing framework for all partner libraries.

58 changes.

This period focused on establishing the LangChain v1 framework, introducing unified factory functions for models and embeddings, and implementing a comprehensive agent middleware system for cross-cutting concerns. It also involved integrating numerous new provider partners, standardizing model profile data, and adding support for the Model Context Protocol (MCP).

This change introduces a set of utility scripts for the new \langchain-openrouter\ partner package to support development and CI workflows. It includes \check\_imports.py\ to validate Python file imports, \check\_version.py\ to ensure version consistency between \pyproject.toml\ and \\_version.py\, and \lint\_imports.sh\ to prevent unauthorized imports from \langchain\ or \langchain\_experimental\ namespaces. These tools help maintain code quality and consistency for the new provider integration.

libs/partners/openrouter/scripts · high confidence

This change introduces three new scripts for the Fireworks partner integration to enforce code quality and consistency. \check\_imports.py\ validates that Python files load without errors, \check\_version.py\ ensures the package version in \pyproject.toml\ matches the version defined in \\_version.py\, and \lint\_imports.sh\ prevents unauthorized imports from \langchain\ or \langchain\_experimental\ (allowing only specific v1 middleware paths).

libs/partners/fireworks/scripts · high confidence

Users can now integrate OpenAI's moderation endpoint into their agents via the new \OpenAIModerationMiddleware\. This middleware intercepts agent traffic to check user inputs, model outputs, and optionally tool results for policy violations. It supports configurable moderation models (defaulting to \omni-moderation-latest\) and allows users to define how violations are handled—either by raising an error, ending the run, or replacing the flagged content with a custom message. The implementation is exposed through the \langchain\_openai.middleware\ package.

_libs/partners/openai/langchain\openai/middleware · high confidence

The Exa partner library now includes three new scripts in the \scripts\ directory to enforce code quality and consistency during development and CI. \check\_imports.py\ validates that specified Python files can be successfully imported, \check\version.py\ ensures the version string in \pyproject.toml\ matches the \\\version\\_\ variable in \langchain\_exa/\_version.py\, and \lint\_imports.sh\ prevents accidental imports from \langchain\ or \langchain\_experimental\ (with specific allowances for \langchain.agents\ and \langchain.tools\).

libs/partners/exa/scripts · high confidence

The library now includes a new \import\_utils.py\ module that provides helper functions to detect the presence and versions of \optimum\, \optimum.intel\, and \openvino\ packages. This enables the Hugging Face integration to conditionally support features dependent on these libraries, such as Intel IPEX models, by checking availability at runtime rather than failing on import.

_libs/partners/huggingface/langchain\huggingface/utils · high confidence

The \langchain\_deepseek\ package now includes a \data\ directory containing auto-generated model profiles for DeepSeek models (including \deepseek-flash\, \deepseek-v4-flash\, \deepseek-v4-flash-vision-exp\, and \deepseek-v4-pro\). This data, sourced from models.dev, provides metadata such as token limits, input/output capabilities, and feature flags. The profiles are augmented via a TOML configuration file to explicitly enable \tool\_call\_streaming\ for the provider.

_libs/partners/deepseek/langchain\deepseek/data · high confidence

This change introduces a set of utility scripts for the new Groq partner integration located in libs/partners/groq/scripts. The check\version.py script validates that the package version defined in pyproject.toml matches the \\version\\_ variable in the source code to prevent mismatches. The check\_imports.py script ensures that specific Python files can be loaded without import errors. Additionally, lint\_imports.sh enforces coding standards by preventing imports from langchain or langchain\experimental (with specific allowances for langchain.agents and langchain.tools), and an \\init\\_.py file is added to define the scripts module.

libs/partners/groq/scripts · high confidence

The Hugging Face partner package now includes a dedicated data module containing auto-generated model profiles sourced from models.dev, covering details such as token limits, input/output modalities, and capabilities like tool calling and structured outputs for models including MiniMax and Qwen series. A configuration file (\profile\_augmentations.toml\) is also introduced to allow provider-specific overrides, such as enabling tool call streaming by default.

_libs/partners/huggingface/langchain\huggingface/data · high confidence

The Ollama partner package now includes three new scripts in its \scripts\ directory to support development and CI workflows. \check\_imports.py\ allows developers to verify that specific Python files load without errors, while \check\_version.py\ ensures version consistency between \pyproject.toml\ and the package's \\_version.py\ file to prevent release mismatches. Additionally, \lint\_imports.sh\ enforces import hygiene by preventing direct imports from \langchain\ or \langchain\_experimental\ (with specific allowances for \langchain.agents\ and \langchain.tools\), helping to maintain proper package boundaries.

libs/partners/ollama/scripts · high confidence

This change introduces three new scripts to the Hugging Face partner library to enforce code quality and consistency. \check\_imports.py\ validates that Python files can be loaded without errors, \check\_version.py\ ensures the version string in \pyproject.toml\ matches the one in \\_version.py\ to prevent release mismatches, and \lint\_imports.sh\ prevents accidental imports from \langchain\ or \langchain\_experimental\ packages, allowing only specific legacy paths.

libs/partners/huggingface/scripts · high confidence

The Nomic partner integration now includes three new scripts to enforce code quality and consistency: \check\_imports.py\ validates that Python files load without errors, \check\_version.py\ ensures the version in \pyproject.toml\ matches \langchain\_nomic/\_version.py\ to prevent mismatches, and \lint\_imports.sh\ prevents importing from \langchain\ or \langchain\_experimental\ (except for specific v1 middleware paths).

libs/partners/nomic/scripts · high confidence

The example selectors in \langchain\_core\ (including \BaseExampleSelector\, \LengthBasedExampleSelector\, and \SemanticSimilarityExampleSelector\) now expose asynchronous methods (\aadd\_example\ and \aselect\_examples\). This allows users to add examples and select relevant ones for prompts without blocking the event loop, improving performance in async applications.

_libs/core/langchain\_core/example\selectors · high confidence

The DeepSeek partner library now includes three new scripts in its \scripts\ directory to enforce code quality and consistency during development and CI. \check\_imports.py\ validates that Python files can be loaded without errors, \check\version.py\ ensures the version defined in \pyproject.toml\ matches the \\\version\\_\ variable in the package's \\_version.py\, and \lint\_imports.sh\ prevents accidental imports from \langchain\ or \langchain\_experimental\ (except for allowed v1 middleware paths).

libs/partners/deepseek/scripts · high confidence

This change introduces the \langchain-exa\ package (version 1.1.0), providing LangChain components for the Exa Search API. It adds \ExaSearchRetriever\ for document retrieval, \ExaSearchResults\ and \ExaFindSimilarResults\ tools for search and similarity queries, and exposes \HighlightsContentsOptions\ and \TextContentsOptions\ from the underlying \exa\_py\ library. The integration supports search types (auto, deep, fast), domain filtering, date ranges, and content options like highlights and summaries.

_libs/partners/exa/langchain\exa · high confidence

The \langchain-huggingface\ partner integration is now available as a standalone package (version 1.2.2). This release introduces the \ChatHuggingFace\ chat model, \HuggingFaceEmbeddings\ and \HuggingFaceEndpointEmbeddings\ for embedding tasks, and \HuggingFaceEndpoint\ and \HuggingFacePipeline\ for LLM inference, providing a unified entry point for Hugging Face models within LangChain.

_libs/partners/huggingface/langchain\huggingface · high confidence

The internal \\_security\ module has been introduced to provide robust Server-Side Request Forgery (SSRF) protection. This includes an \SSRFPolicy\ that blocks private IP ranges, localhost, cloud metadata endpoints (such as AWS and GCP metadata services), and Kubernetes internal addresses. The module exposes validation functions (\validate\_url\, \validate\_resolved\_ip\) and \httpx\ transport wrappers (\SSRFSafeTransport\, \SSRFSafeSyncTransport\) that enforce these policies by resolving DNS and pinning requests to safe IPs, raising \SSRFBlockedError\ when violations are detected.

_libs/core/langchain\_core/\security · high confidence

LangChain v1 now includes a comprehensive Agent Middleware system located in \langchain.agents.middleware\. This new feature allows developers to inject cross-cutting concerns into agent execution flows. The package exports a wide range of built-in middleware components, including \HumanInTheLoopMiddleware\ for human review of tool calls, \PIIMiddleware\ for sensitive data detection and redaction, \SummarizationMiddleware\ for context window management, \ModelCallLimitMiddleware\ for enforcing usage quotas, and \ToolRetryMiddleware\ for resilient tool execution. It also provides infrastructure for custom middleware via decorators like \wrap\_model\_call\ and \wrap\_tool\_call\, and includes specialized tools like \FilesystemFileSearchMiddleware\ for file operations and \ShellToolMiddleware\ for secure shell execution with configurable execution policies.

_libs/langchain\v1/langchain/agents/middleware · high confidence

Adds the \ChatHuggingFace\ class and supporting utilities (TGI message/response types, conversion helpers) to the Hugging Face partner package, enabling users to interact with Hugging Face models via the standard LangChain chat interface.

_libs/partners/huggingface/langchain\_huggingface/chat\models · high confidence

The \langchain\_huggingface.llms\ module now exposes \HuggingFaceEndpoint\ and \HuggingFacePipeline\ classes. \HuggingFaceEndpoint\ enables inference via the Hugging Face Inference API (or third-party providers like Novita) with support for async streaming, configurable generation parameters, and environment-based token configuration. \HuggingFacePipeline\ allows running models locally using the \transformers\ library, supporting tasks such as text generation, summarization, and image-text-to-text, with explicit handling for device mapping and backend selection (including a deprecation notice for the retired IPEX backend in favor of native PyTorch acceleration).

_libs/partners/huggingface/langchain\huggingface/llms · high confidence

Adds the \langchain-deepseek\ package (version 1.1.1), providing the \ChatDeepSeek\ class to interact with DeepSeek's API. The integration extends the OpenAI-compatible base to handle DeepSeek-specific features, including mapping \prompt\_cache\_hit\_tokens\ to usage metadata, supporting strict beta structured output, and ensuring correct tool choice behavior for Azure deployments.

_libs/partners/deepseek/langchain\deepseek · high confidence

This release adds the \langchain-perplexity\ partner package (v1.4.1), providing a complete set of components to interact with Perplexity AI. Users can now use \ChatPerplexity\ for chat completions, \PerplexityEmbeddings\ for vector embeddings, and \PerplexitySearchRetriever\ or \PerplexitySearchResults\ for web search capabilities. The integration includes specialized output parsers (\ReasoningJsonOutputParser\, \ReasoningStructuredOutputParser\) to handle reasoning model outputs by stripping think tags, and supports both the standard Chat Completions API and the new Responses (Agent) API via a dedicated flag.

_libs/partners/perplexity/langchain\perplexity · high confidence

Adds the \langchain-xai\ package (version 1.3.0), providing the \ChatXAI\ class to interact with xAI's Chat Completions API. This new integration allows users to instantiate and invoke xAI models (such as Grok) using standard LangChain interfaces, including support for streaming, async operations, and structured output.

_libs/partners/xai/langchain\xai · high confidence

The \langchain\_nomic\ package is now available, providing the \NomicEmbeddings\ class for generating text and image embeddings. Users can configure the model via the \model\ parameter, specify embedding dimensions with \dimensionality\, and choose between remote, local, or dynamic inference modes using \inference\_mode\. Local inference allows execution on specific devices (e.g., CPU/GPU) via the \device\ parameter, while the new \vision\_model\ parameter enables image embedding capabilities through \embed\_image\.

_libs/partners/nomic/langchain\nomic · high confidence

The \langchain\_core.vectorstores\ package now provides a foundational \VectorStore\ abstract base class and a concrete \InMemoryVectorStore\ implementation for local, in-memory vector storage and search. Users can now import \VectorStore\, \VectorStoreRetriever\, and \InMemoryVectorStore\ directly from \langchain\_core.vectorstores\. The \InMemoryVectorStore\ supports adding, deleting, and searching documents using cosine similarity (via NumPy or simsimd), with optional filtering and maximal marginal relevance (MMR) retrieval. The base \VectorStore\ defines standard interfaces like \add\_texts\, \delete\, \similarity\_search\, and async equivalents, enabling consistent integration across different vector store backends.

_libs/core/langchain\core/vectorstores · high confidence

LangChain v1 now provides a new \create\_agent\ factory function (exposed in \langchain.agents\) to build agents with a modern middleware architecture. This replaces the previous \create\_react\_agent\ pattern, allowing users to attach middleware hooks for tracing, tool call wrapping, and state management. The factory includes built-in support for structured output via \ProviderStrategy\ and \ToolStrategy\, enabling typed responses from models like GPT-4o and GPT-5. Additionally, nested agents (subagents) invoked by tools are now surfaced as typed handles on \run.subagents\, providing clear causality tracking for nested execution flows.

_libs/langchain\v1/langchain/agents · high confidence

The \libs/standard-tests\ directory is now published as the \langchain-tests\ package, providing a standardized testing framework for LangChain integrations. It includes base classes for unit and integration tests across chat models, embeddings, vector stores, retrievers, tools, caches, and key-value stores. The package features a pytest plugin that automatically forwards LangSmith CI environment variables (tags and metadata) into tracing context when running in GitHub Actions, and uses a custom VCR serializer to safely handle binary data in recorded cassettes.

libs/standard-tests · high confidence

The \langchain.mcp\ namespace is now available (in beta) to connect LangChain agents to Model Context Protocol (MCP) servers. This release introduces the \MCPAdapter\ class, which adapts MCP targets—such as HTTP URLs, local script paths, or pre-built FastMCP clients—into LangChain tools suitable for \create\_agent\. It also includes \as\_langchain\_tool\ for converting individual MCP tools and \MCPToolArtifact\ for attaching structured content. A key behavioral addition is interrupt-driven elicitation: when an MCP server requests input mid-call, the adapter automatically triggers a LangGraph \interrupt()\, allowing a human to provide answers and resume the run. The namespace raises a \LangChainBetaWarning\ on import to indicate that the API is actively being developed.

_libs/langchain\v1/langchain/mcp · high confidence

The \langchain\_core.language\_models\ package now exposes a new streaming protocol via \BaseChatModel.stream\_events(version="v3")\ and \astream\_events(version="v3")\, which emit structured \content-block-delta\ and \content-block-finish\ events instead of raw message chunks. This change is supported by a new \\_compat\_bridge\ module that translates existing \AIMessageChunk\ streams into the new protocol, and a \ChatModelStream\ class that provides typed projections (e.g., \.text\, \.tool\_calls\) for accumulating these events. Additionally, a \ModelProfile\ type and \model.profile\ property have been added to \BaseChatModel\ to expose model capabilities (such as supported input types like images, audio, and PDFs) sourced from \langchain-model-profiles\. The package also includes updated fake models (\FakeListChatModel\, \FakeMessagesListChatModel\) and utility functions for handling OpenAI-style data blocks and message normalization.

_libs/core/langchain\_core/language\models · high confidence

The \langchain-mistralai\ package is now available as a standalone integration, providing \ChatMistralAI\ for chat completions and \MistralAIEmbeddings\ for vector embeddings. This release includes support for Mistral's v1 content blocks, enabling citation metadata and reasoning (thinking) content to be surfaced in responses, alongside standard tool calling and structured output capabilities.

_libs/partners/mistralai/langchain\mistralai · high confidence

Users can now integrate with the OpenRouter unified API through the new \langchain-openrouter\ package. This release adds the \ChatOpenRouter\ class, enabling access to hundreds of models from multiple providers (such as OpenAI, Anthropic, and Google) within LangChain applications. The integration supports standard chat parameters, streaming, tool calling, and includes features for attribution, session tracking, and cost metadata.

_libs/partners/openrouter/langchain\openrouter · high confidence

The \libs/partners/typesafe\ package is introduced, providing the \TypeSafeClassifier\ LangChain Runnable for probabilistic classification (binary Noul, categorical Choice, and ordinal Score questions) and two experimental agent middleware components: \ModelRouterMiddleware\, which selects an agent's model based on a TypeSafe classification of the latest human message, and \AutoModeMiddleware\, which intercepts tool calls to block risky executions before they run. The integration handles LangChain message serialization, custom HTTP clients, and standard LangChain error hierarchies.

libs/partners/typesafe · high confidence

The \langchain\core.prompts\ package now uses lazy imports via a custom \\\getattr\\\ in \\\init\\_.py\ to improve startup performance, exposing classes like \ChatPromptTemplate\, \PromptTemplate\, and \MessagesPlaceholder\ on demand. This release also introduces several new prompt template types: \DictPromptTemplate\ for formatting dictionary-based templates, \ImagePromptTemplate\ for multimodal image inputs (with file path loading removed for security), and \FewShotPromptWithTemplates\ which allows prefix/suffix components to be full prompt templates rather than just strings. Additionally, \MessagesPlaceholder\ now supports an \optional\ flag and a \n\_messages\ limit to control how many history messages are included.

_libs/core/langchain\core/prompts · high confidence

This change introduces the \langchain\_model\_profiles\ package, providing the infrastructure to manage and refresh model profile data. It includes a CLI (\cli.py\) to fetch and update profiles from models.dev, a diffing engine (\\_summary.py\) that generates plain-English Markdown summaries of changes (new, removed, or modified models and fields) for pull requests, and support for profile augmentations via TOML configuration. This enables maintainers to easily review and merge updates to model capabilities and metadata.

_libs/model-profiles/langchain\_model\profiles · high confidence

A new \block\_translators\ module has been added to \langchain\_core\ to handle the conversion of provider-specific message content (from Anthropic, Bedrock, Bedrock Converse, Google GenAI, Google VertexAI, Groq, and OpenAI) into the standard v1 \ContentBlock\ format. This change introduces a centralized registry system where each provider can register its own translation logic for both full messages and streaming chunks. For users, this means that accessing \content\_blocks\ on \AIMessage\ or \AIMessageChunk\ instances from these providers will now yield standardized, structured blocks (such as text, images, files, and tool calls) rather than raw provider-specific dictionaries, ensuring consistent behavior across different model integrations.

_libs/core/langchain\_core/messages/block\translators · high confidence

The text splitting utilities are now available as a standalone \langchain-text-splitters\ package, decoupled from the main \langchain\ library. This new package includes the full suite of splitters (such as \CharacterTextSplitter\, \HTMLHeaderTextSplitter\, \MarkdownHeaderTextSplitter\, and \JSFrameworkTextSplitter\) with lazy loading for heavy optional dependencies like \nltk\ and \spacy\ to keep the initial import lightweight. It also provides a dedicated development environment with a \Makefile\ for linting, formatting, and testing, along with standard project files like \LICENSE\ and \README.md\.

libs/text-splitters · high confidence

This change introduces the new \langchain\_openai\ package (version 1.6.6), which consolidates OpenAI integrations including \ChatOpenAI\, \OpenAI\, \AzureChatOpenAI\, \OpenAIEmbeddings\, and a new \custom\_tool\ utility. The package adds support for the OpenAI Python SDK 3.0 by dynamically resolving the underlying HTTP client (\httpx\ vs \httpx2\) to ensure compatibility. It also introduces \ChatOpenAICodex\, a chat model that authenticates via ChatGPT OAuth (Authorization Code Flow with PKCE) for subscription-based access, storing tokens in \\~/.langchain/chatgpt-auth.json\. Additionally, the package exports \StreamChunkTimeoutError\ to help users handle streaming hangs.

_libs/partners/openai/langchain\openai · high confidence

The \langchain\_v1\ package now includes a new \init\_chat\_model\ factory function that simplifies instantiating chat models by automatically inferring the provider from the model name and handling optional dependency installation. This entry point exposes \BaseChatModel\ and \init\_chat\_model\, registering a comprehensive set of built-in providers including Anthropic, AWS Bedrock (standard, converse, and Mantle variants), Azure AI Foundry, OpenAI, Google Vertex/GenAI, Hugging Face, Meta, Upstage, and LangSmith (via gateway). Users can now create models across these providers with a single call, with the system automatically resolving the correct integration package and class.

_libs/langchain\_v1/langchain/chat\models · high confidence

The \langchain\_core.\api\ module now provides the infrastructure for marking LangChain components as beta or deprecated. This includes the \@beta\ and \@deprecated\ decorators, which emit specific warnings (\LangChainBetaWarning\ and \LangChainDeprecationWarning\) to users while suppressing them for internal library calls. The module also supports lazy loading of these utilities via a custom \\\getattr\\_\ to reduce import overhead, and provides helper functions for path manipulation used in warning messages.

_libs/core/langchain\_core/\api · high confidence

The \langchain-core\ package is introduced to define the base abstractions for the LangChain ecosystem, including interfaces for chat models, LLMs, vector stores, retrievers, and the universal invocation protocol (Runnables). This new location establishes the core schema definitions for agents, caching mechanisms, chat message history, and key-value stores, while also providing standard exception types and rate-limiting utilities. By centralizing these foundational components, the library ensures a lightweight dependency footprint and provides a stable API layer for third-party integrations and higher-level LangChain features.

_libs/core/langchain\core · high confidence

The \langchain\_core.output\parsers\ module has been introduced to provide a centralized set of parsers for converting LLM outputs into structured data. This includes \JsonOutputParser\ and \PydanticOutputParser\ for JSON and Pydantic model validation, \XMLOutputParser\ with secure \defusedxml\ support, and list parsers (\CommaSeparatedListOutputParser\, \ListOutputParser\, etc.). The module also exports OpenAI tools parsers (\JsonOutputToolsParser\, \PydanticToolsParser\) and base classes like \BaseOutputParser\ and \BaseTransformOutputParser\ to support streaming and cumulative parsing. All parsers are lazily imported via \\\getattr\\_\ to optimize startup time.

_libs/core/langchain\_core/output\parsers · high confidence

This change introduces the core \Runnable\ objects and the LangChain Expression Language (LCEL) to \langchain\_core\. It provides a declarative API for building production-grade programs that inherently support synchronous, asynchronous, batch, and streaming operations. The module exposes key composition primitives such as \RunnableSequence\ (for chaining steps with the \\|\ operator) and \RunnableParallel\ (for concurrent execution), along with utility classes like \RunnableLambda\, \RunnableBranch\, \RunnableWithFallbacks\, and \RunnableWithMessageHistory\. It also includes configuration management via \RunnableConfig\ and graph visualization capabilities using Mermaid and ASCII diagrams.

_libs/core/langchain\core/runnables · high confidence

The \langchain\_openai.llms\ package has been introduced, providing the \OpenAI\ and \AzureOpenAI\ classes for large language model completions. This new module separates text-completion models from chat models (which reside in \chat\_models/\) and implements the \BaseOpenAI\ foundation class. It supports configuration via environment variables, handles Azure-specific endpoints and deployments, and includes validation logic to ensure compatibility with the OpenAI Python SDK v1.x.

_libs/partners/openai/langchain\openai/llms · high confidence

The \libs/langchain\ directory is now structured as the standalone \langchain-classic\ package, providing the legacy chains, community re-exports, and deprecated functionality. This change introduces a complete development environment for the package, including a \Makefile\ with targets for linting, formatting, and testing via \uv\, a \dev.Dockerfile\ based on Python 3.14, and a \uv.lock\ file for dependency management. It also adds a \.dockerignore\ file, an MIT \LICENSE\, and an updated \README.md\ directing users to the main \langchain\ package for new development.

libs/langchain · high confidence

The document loader base classes (BaseLoader, BaseBlobParser) and blob schema (Blob, BlobLoader) have been moved from the community package into langchain\_core, providing a stable, core-level interface for loading and parsing documents. This location also introduces the LangSmithLoader, which allows users to load LangSmith dataset examples as Document objects for few-shot retrieval, supporting features like nested content keys, dataset splits, and versioning.

_libs/core/langchain\_core/document\loaders · high confidence

The \langchain\_anthropic\ package now includes a dedicated \middleware\ module that provides several new capabilities for agents using Anthropic models. Users can now leverage \AnthropicPromptCachingMiddleware\ to optimize API usage by caching system messages and tool definitions. The package also introduces \ClaudeBashToolMiddleware\ to expose the native bash tool, \StateFileSearchMiddleware\ for glob and grep searches over virtual files, and \FilesystemClaudeMemoryMiddleware\ and \StateClaudeTextEditorMiddleware\ for managing text editing and memory tools via state or filesystem backends.

_libs/partners/anthropic/langchain\anthropic/middleware · high confidence

The \langchain\core.documents\ module has been restructured to support lazy imports via a custom \\\getattr\\\ in \\\init\\_.py\, improving startup performance. This change introduces new core abstractions for data retrieval workflows: \BaseMedia\ (providing optional \id\ and \metadata\ fields), \Blob\ (for raw data loading with MIME type and encoding support), and \BaseDocumentCompressor\ (for post-processing retrieved documents). These classes are distinct from LLM chat message content blocks and are intended for use in RAG pipelines, vector stores, and document processing.

_libs/core/langchain\core/documents · high confidence

The \langchain\_core.indexing\ package introduces a new high-level API for indexing documents into vector stores, designed to handle deduplication and avoid re-indexing unchanged content. This change adds the \DocumentIndex\ abstraction and an \InMemoryDocumentIndex\ implementation for testing or lightweight use, alongside the \RecordManager\ interface for tracking document state. The \index\ and \aindex\ functions now support configurable hashing algorithms (SHA-1, SHA-256, SHA-512, blake2b) with a warning for the default SHA-1, and include logic to validate batch sizes to prevent infinite loops. The API also exposes \UpsertResponse\ and \DeleteResponse\ types to clarify upsert and deletion semantics.

_libs/core/langchain\core/indexing · high confidence

A new \langchain.messages\ module has been added to the v1 library, re-exporting a comprehensive set of message types, content blocks, and utility functions from \langchain\_core\. This includes role-based messages (HumanMessage, AIMessage, SystemMessage, ToolMessage), content block types for text, images, audio, video, and data, as well as tool call representations, usage metadata, and the \trim\_messages\ utility. Users can now import these standard message components directly from \langchain.messages\ instead of \langchain\_core.messages\.

_libs/langchain\v1/langchain/messages · high confidence

Added a new set of self-contained scripts in \libs/langchain\_v1/examples/mcp\ that demonstrate how to use the \langchain.mcp.MCPAdapter\ to connect LangChain agents to Model Context Protocol (MCP) servers. The examples cover connecting to remote servers (e.g., DeepWiki), using multiple servers behind a single adapter, and handling various transport modes (in-memory, stdio, HTTP). They also showcase advanced features such as authentication (static bearer tokens and full OAuth 2.1 flows), human-in-the-loop interactions (eliciting user input mid-call and gating destructive tools behind approval), and compatibility with different MCP protocol eras. Supporting files include shared mock MCP servers and a \langgraph.json\ configuration for running a per-user fleet graph via \langgraph dev\.

_libs/langchain\v1/examples · high confidence

The \libs/partners/openai/scripts\ directory now includes several new utility scripts: \check\_imports.py\ and \lint\_imports.sh\ to validate import correctness and prevent unauthorized dependencies; \check\_version.py\ to ensure version consistency between \pyproject.toml\ and \\_version.py\; and \record\_codex\_cassettes.sh\ (along with \RECORD\_CODEX\_CASSETTES.md\) to facilitate recording and scrubbing VCR cassettes for the experimental \ChatOpenAICodex\ integration tests, ensuring no OAuth secrets leak into CI artifacts.

libs/partners/openai/scripts · high confidence

LangChain v1 introduces a new \init\_embeddings\ function in \libs/langchain\v1/langchain/embeddings/base.py\ that provides a unified way to instantiate embedding models across multiple providers (such as OpenAI, Azure AI, Bedrock, Cohere, and Google Genai) using a single API. This factory parses provider-specific model strings (e.g., \openai:text-embedding-3-small\) or accepts explicit provider arguments, handling the underlying imports and instantiation logic. The \\\init\\_.py\ module exposes this factory and the core \Embeddings\ interface, while also warning users that community and cache-backed embeddings have moved to \langchain-classic\.

_libs/langchain\v1/langchain/embeddings · high confidence

Added three new scripts to the Chroma partner location to improve build integrity: \check\_imports.py\ verifies that Python files can be imported without error, \check\_version.py\ ensures version consistency between \pyproject.toml\ and \\_version.py\, and \lint\_imports.sh\ prevents accidental imports from \langchain\ or \langchain\_experimental\ namespaces.

libs/partners/chroma/scripts · high confidence

The \langchain\_core.utils\ package is now a public, lazily-imported module that exposes a comprehensive set of utilities—including environment variable resolution (\get\_from\_env\, \get\_from\_dict\_or\_env\), string formatting (\StrictFormatter\), iterator helpers (\batch\_iterate\, \abatch\_iterate\), JSON parsing (\parse\_partial\_json\), and HTML link extraction—without eagerly importing their dependencies. This location also introduces private helpers for resolving LangSmith gateway configuration (\\_gateway.py\), which centralizes the precedence rules for base URLs and API keys so that provider integrations can route requests through the LangSmith proxy consistently.

_libs/core/langchain\core/utils · high confidence

The \langchain-qdrant\ package has been updated to version 1.1.0, introducing native support for sparse embeddings and hybrid retrieval modes. Users can now utilize the \FastEmbedSparse\ class for sparse text embeddings and configure the \QdrantVectorStore\ with a \RetrievalMode\ enum (DENSE, SPARSE, or HYBRID) to combine dense and sparse vectors in a single query. The integration also exposes a new \QdrantVectorStore\ class alongside the legacy \Qdrant\ class, which is now deprecated, and includes built-in support for Maximal Marginal Relevance (MMR) search.

_libs/partners/qdrant/langchain\qdrant · high confidence

The \langchain-anthropic\ partner package has been updated to version 1.7.4, introducing support for the Anthropic Python SDK 1.x alongside the existing 0.x compatibility layer. This update ensures that sampling parameters like \temperature\, \top\_p\, and \top\_k\ are correctly routed to \extra\_body\ when using SDK 1.x, which no longer accepts them as direct arguments. The release also adds support for new model features including Claude Opus 5, Claude Fable 5.1, and the \claude-sonnet-4-5\ default model, while introducing built-in tool support for features like web fetch, code execution, MCP toolsets, and computer use. Additionally, the package now includes a \ChatAnthropicBedrockWrapper\ for AWS Bedrock integration, improved streaming usage metadata, and standardized model profiles for better token limit handling.

_libs/partners/anthropic/langchain\anthropic · high confidence

The \LLMMathChain\ class and its associated prompt template have been removed from the \langchain/chains/llm\_math\ module. This eliminates the legacy chain that previously interpreted natural language questions, generated Python code via an LLM, and executed it using a local Python kernel to perform calculations.

_langchain/chains/llm\math · high confidence

The \SelfAskWithSearchChain\ class and its associated helper functions (such as \extract\_answer\, \extract\_question\, and console formatting utilities) have been removed from the codebase. This eliminates the specific chain logic that performed iterative question-answering by combining an LLM with a SerpAPI search chain, meaning users can no longer instantiate or use this specific chain type.

_langchain/chains/self\_ask\_with\search · high confidence

The \langchain.llms\ module has been removed, deleting the base \LLM\ interface and specific wrappers for OpenAI and Cohere. This eliminates the legacy synchronous \\_\call\\_\-based API for these providers, requiring users to migrate to the current LLM abstractions.

langchain/llms · high confidence

The \langchain/chains\ package has removed its core implementation files, including the base \Chain\ interface, \LLMChain\, \PythonChain\, and \SerpAPIChain\. Users relying on these specific classes for building chains will encounter import errors and must migrate to the updated chain architecture or alternative implementations provided in newer versions of the library.

langchain/chains · high confidence

The \examples\ directory has removed three Jupyter notebooks (\llm\_math.ipynb\, \self\_ask\_with\_search.ipynb\, and \simple\_prompts.ipynb\) that demonstrated older LangChain patterns, such as \LLMMathChain\, \SelfAskWithSearchChain\, and the legacy \Prompt\ class. Users relying on these specific examples for reference or copy-pasting will no longer find them in this location.

examples · high confidence

The legacy \langchain\ package structure has been removed, specifically deleting the \VERSION\ file, the main \\_\init\\_.py\ entry point, \formatting.py\, and \prompt.py\. This eliminates the old \Prompt\ schema, the \StrictFormatter\ utility, and the direct imports for chains (like \LLMChain\, \SerpAPIChain\) and LLMs (like \OpenAI\, \Cohere\) that were previously exposed at the top level. Users relying on these specific legacy imports or the \0.0.1\ version metadata will need to update their code to use the new modular package structure.

langchain · high confidence

The \langchain\_core.load\ module has been significantly hardened to prevent injection attacks during deserialization. Plain user data (dicts) containing an \'lc'\ key is now automatically escaped during serialization to prevent confusion with LangChain object manifests, and these escaped dicts are unwrapped as plain data during loading. Deserialization now uses a strict allowlist approach: only classes explicitly defined in the serialization mappings are instantiated, and the default \allowed\_objects\ mode is \'core'\ (which is marked unsafe for untrusted input). Users must now explicitly restrict \allowed\_objects\ (e.g., to \'messages'\ or a specific list of classes) when loading untrusted manifests to prevent arbitrary code execution or SSRF via constructor side effects. Additionally, \secrets\_from\_env\ defaults to \False\ to prevent accidental environment variable leakage, and \InitValidator\ is exposed to allow custom validation during object initialization.

_libs/core/langchain\core/load · high confidence

The Pygments library has been updated to version 2.20.0 or higher across all packages to address the [CVE redacted] vulnerability.

(dependencies) · high confidence

The xAI partner library now includes new scripts to enforce code quality and release integrity during CI. A new \lint\_imports.sh\ script prevents accidental imports from \langchain\ or \langchain\_experimental\ (except for allowed v1 middleware paths), ensuring proper isolation. Additionally, \check\version.py\ validates that the package version in \pyproject.toml\ matches the \\\version\\_\ in \langchain\_xai/\_version.py\, and \check\_imports.py\ verifies that Python files can be loaded without errors. These changes help prevent version mismatches and import violations in the xAI integration.

libs/partners/perplexity/scripts, libs/partners/xai/scripts · high confidence

New scripts have been added to the Anthropic partner library to enforce code quality and release integrity during CI. The \check\_imports.py\ script validates that specified Python files load without errors, while \lint\_imports.sh\ prevents accidental imports from \langchain\ or \langchain\_experimental\ (except for allowed v1 middleware paths). Additionally, \check\version.py\ ensures that the package version defined in \pyproject.toml\ matches the \\\version\\_\ variable in \\_version.py\, preventing version mismatches.

libs/partners/anthropic/scripts · high confidence

The Mistral AI partner package now includes three new scripts in its \scripts\ directory to enforce code quality and consistency. \check\_imports.py\ validates that Python files load without errors, \check\version.py\ ensures the version defined in \pyproject.toml\ matches the \\\version\\_\ variable in \\_version.py\ to prevent mismatches, and \lint\_imports.sh\ prevents accidental imports from \langchain\ or \langchain\_experimental\ (except for allowed v1 middleware paths).

libs/partners/mistralai/scripts · high confidence

Two new utility scripts have been added to the langchain v1 scaffolding to improve release safety and development hygiene. The \check\_imports.py\ script allows developers to quickly verify that a list of Python files can be loaded by the interpreter without errors, helping catch syntax or dependency issues before running expensive tests. The \check\version.py\ script ensures that the version string defined in \pyproject.toml\ matches the \\\version\\\ variable in \langchain/\\init\\_.py\, preventing version mismatches during commits.

_libs/langchain\v1/scripts · high confidence

New scripts have been introduced to the Qdrant partner package to enforce code quality and release integrity. \check\_imports.py\ validates that Python files load without errors, \check\_version.py\ ensures the version string in \pyproject.toml\ matches the one in \\_version.py\ to prevent mismatches, and \lint\_imports.sh\ prevents accidental imports from \langchain\ or \langchain\_experimental\ namespaces.

libs/partners/qdrant/scripts · high confidence

The embeddings functionality, including the base \Embeddings\ interface and the \FakeEmbeddings\ and \DeterministicFakeEmbedding\ test utilities, has been moved into the \langchain\core\ package. This change introduces lazy loading for these classes via a custom \\\getattr\\\ implementation in the \\\init\\_.py\ file, which improves import performance by deferring the loading of the underlying modules until the classes are actually accessed.

_libs/core/langchain\core/embeddings · high confidence

The \langchain\_v1\ package now exposes \BaseRateLimiter\ and \InMemoryRateLimiter\ from \langchain\_core\ at \langchain.rate\_limiters\. Users can import these classes directly from this new location to limit the rate of requests to APIs when using \BaseChatModel\.

_libs/langchain\_v1/langchain/rate\limiters · high confidence

The HuggingFaceEmbeddings class now accepts a dedicated \query\_encode\_kwargs\ parameter, allowing users to configure encoding behavior (such as batch size or normalization) differently for search queries versus stored documents, while still falling back to the general \encode\_kwargs\ if the new parameter is empty. Additionally, the deprecated Intel IPEX backend has been removed in favor of native PyTorch support, and the \model\ parameter is now exposed as an alias for \model\_name\ for consistency.

_libs/partners/huggingface/langchain\huggingface/embeddings · high confidence

The \langchain\_openai\ package is restructured into a dedicated \chat\_models\ module, introducing \ChatOpenAI\ and \AzureChatOpenAI\ classes that now support the OpenAI Responses API (including structured output, built-in tools, and reasoning summaries) alongside the legacy Chat Completions API. A new \\_client\_utils\ module enhances streaming reliability by adding per-chunk timeout wrappers and platform-aware TCP keepalive socket tuning, while a \\_compat\ module manages backward-compatible conversion between v0.3 and new Responses API message formats. Additionally, an experimental \\_ChatOpenAICodex\ class is added to support ChatGPT OAuth-backed Codex access, and a \custom\_tool\ decorator is provided for defining OpenAI custom tools with freeform string inputs.

_libs/partners/openai/langchain\_openai/chat\models · high confidence

The langchain-groq integration is updated to version 1.1.3, introducing a specific GroqContextOverflowError that maps Groq's context-length errors to LangChain's standard exception for better error handling. The package also adds a compatibility layer (\_convert\_from\_v1\_to\_groq) to handle conversion of LangChain v1 content blocks (such as reasoning and server tool calls) into the format expected by the Groq API, ensuring smoother interoperability during migration or mixed-version usage.

_libs/partners/groq/langchain\groq · high confidence

The \langchain\core.callbacks\ package now uses dynamic, lazy imports via \\\getattr\\_\ to reduce startup overhead, exposing all standard handlers and managers (including \UsageMetadataCallbackHandler\, \StdOutCallbackHandler\, \FileCallbackHandler\, and custom event dispatchers) without forcing immediate module loads. Additionally, \FileCallbackHandler\ now requires context-manager usage (\with FileCallbackHandler(...) as handler:\) for proper file lifecycle management, issuing a deprecation warning for direct instantiation to prevent resource leaks.

_libs/core/langchain\core/callbacks · high confidence

The \langchain\core.outputs\ package now uses dynamic imports via a custom \\\getattr\\_\ to load output classes (such as \LLMResult\, \ChatGeneration\, and \Generation\) only when they are accessed. This change reduces the initial import overhead of the \langchain\_core\ package by deferring the loading of these specific modules, while maintaining the same public API surface for users interacting with model outputs.

_libs/core/langchain\core/outputs · high confidence

The \langchain.tools\ module is now available in the v1 package, providing a dedicated namespace for tool-related components. This location acts as a compatibility layer that re-exports core tool classes (such as \BaseTool\, \tool\, and \ToolException\) from \langchain\_core\ and runtime/state injection utilities (\ToolRuntime\, \InjectedState\, \InjectedStore\) from \langgraph.prebuilt\. This allows existing code to import from \langchain.tools\ without immediate refactoring, while establishing the new v1 structure for tool management.

_libs/langchain\v1/langchain/tools · high confidence

The \langchain\_classic\ package now surfaces deprecation warnings when users import legacy classes and functions (such as \MRKLChain\, \ReActChain\, \LLMChain\, and various agent toolkits) from the root module or submodules. Instead of silently working, these imports now trigger warnings directing users to migrate to the new import paths in \langchain\_classic\ (e.g., \langchain\_classic.agents.MRKLChain\) or \langchain\_community\. Some older agents (like \create\_csv\_agent\) have been moved to \langchain\_experimental\ and will raise an \ImportError\ with instructions to install that package. This change helps users identify and update deprecated code paths before they are removed in a future major version.

_libs/langchain/langchain\classic · high confidence

The \langchain\core.tools\ package has been reorganized into distinct modules (\base\, \convert\, \render\, \retriever\, \simple\, \structured\) and now uses lazy dynamic imports via \\\getattr\\\ in \\\init\\_.py\ to improve startup performance. The core tool classes (\BaseTool\, \StructuredTool\, \Tool\) and the \@tool\ decorator have been updated to support both Pydantic v1 and v2 models, ensuring backward compatibility while adopting modern typing practices. Additionally, the \@tool\ decorator now supports an \extras\ argument for provider-specific fields (e.g., Anthropic cache control), and the \StructuredTool\ is now JSON-serializable by default, fixing previous serialization errors when dumping tool schemas.

_libs/core/langchain\_core/tools, libs/core/langchain\core/tracers · high confidence

A new linting script (lint\_imports.sh) has been added to the model-profiles library to enforce import policies. It prevents code from importing directly from langchain or langchain\_experimental, with specific allowances for langchain.agents and langchain.tools (v1 middleware). This change ensures that dependencies are managed consistently and prevents accidental usage of experimental or base LangChain modules in this library.

libs/model-profiles/scripts · high confidence

The \langchain\core.messages\ package has been reorganized to use lazy imports via a custom \\\getattr\\\ in \\\init\\_.py\, improving startup performance by deferring the loading of heavy message classes until they are accessed. This change introduces a new standardized \content.py\ module defining multimodal content blocks (such as \TextContentBlock\, \ImageContentBlock\, and \ReasoningContentBlock\) and updates message classes like \AIMessage\ and \ToolMessage\ to support these typed content blocks alongside legacy string content. Additionally, \BaseMessage\ now includes an \id\ field for unique identification and a \response\_metadata\ field for provider-specific data, while \ToolMessage\ gains an \artifact\ field to store full tool outputs separate from the content sent to the model.

_libs/core/langchain\core/messages · high confidence

Added scripts to enforce import and version consistency within the core library. The \check\_imports.py\ script validates that Python modules can be successfully imported, while \check\_version.py\ ensures the version defined in \pyproject.toml\ matches the \VERSION\ variable in \langchain\_core/version.py\. Additionally, \lint\_imports.sh\ prevents accidental imports from \langchain\ or \langchain\_experimental\ packages, allowing only specific legacy paths like \langchain.agents\ and \langchain.tools\.

libs/core/scripts · high confidence

Added \check\_imports.py\ and \lint\_imports.sh\ to the LangChain scripts directory to enforce import hygiene and verify module loadability. The Python script allows developers to quickly verify that a list of Python files can be loaded by the interpreter without errors, printing tracebacks for any failures. The shell script enforces specific import rules within the \langchain\_classic\ directory, ensuring that internal modules do not import from disallowed sub-packages and preventing imports from \langchain\_experimental\ or the global namespace of \langchain\_community\.

libs/langchain/scripts · high confidence

The \langchain\_openai.embeddings\ package has been introduced, providing the \OpenAIEmbeddings\ and \AzureOpenAIEmbeddings\ classes. This update migrates the embedding integrations to Pydantic v2 (replacing \.dict()\ with \.model\_dump()\) and aligns with the OpenAI Python SDK 3.x. Key behavioral changes include explicit support for embedding dimensions via the \dimensions\ parameter, a 300,000 token limit per request, and improved Azure authentication handling with dedicated \azure\_endpoint\ and \azure\_ad\_token\_provider\ fields. The module also refactors chunking logic to use a local \chunk\size\\ for looping and runs tokenization in a background thread for async invocations.

_libs/partners/openai/langchain\openai/embeddings · high confidence

The Perplexity integration now includes a dedicated data package containing auto-generated model profiles for Sonar, Sonar Deep Research, Sonar Pro, and Sonar Reasoning Pro. These profiles define specific capabilities such as input/output modalities (text, image, audio, video), token limits, and features like tool calling and reasoning outputs, allowing the integration to accurately reflect the current specifications of Perplexity's models.

_libs/partners/perplexity/langchain\perplexity/data · high confidence

The repository has been restructured for its v0.2 release, replacing the legacy \setup.py\ and root \Makefile\ with a \uv\-based monorepo architecture where each package in \libs/\ manages its own dependencies and build tasks. Development tooling is standardized via a new \.pre-commit-config.yaml\ (enforcing \ruff\ and \mypy\), \.editorconfig\, and \.markdownlint.json\. The \README.md\ has been completely rewritten to reflect the new 'agent engineering platform' positioning, featuring updated installation instructions (\uv add langchain\), new code examples using \init\_chat\_model\, and links to the new documentation site and ecosystem products like LangGraph and Deep Agents.

(repo-wide) · high confidence

The Fireworks partner package now includes refreshed model profile data for models such as DeepSeek V4 Flash, DeepSeek V4 Pro, Ember-1, and GLM-5p1/5p2. This update adds support for the \reasoning\_effort\ parameter (with levels like low, medium, high, etc.) on specific models like DeepSeek V4 Pro and GLM-5p1/5p2, and explicitly declares that native PDF inputs are unsupported for these models.

_libs/partners/fireworks/langchain\fireworks/data · high confidence

The model profile data for the Groq integration has been refreshed to include new models such as Canopy Labs Orpheus variants and the Groq Compound models, along with updated metadata for existing models like Llama 3.1 and Llama 3.3. This ensures the library accurately reflects the latest capabilities, token limits, and input/output modalities available through the Groq API.

_libs/partners/groq/langchain\groq/data · high confidence

The model profile data for the Mistral AI partner package has been refreshed to include new model variants (such as Devstral and Magistral series) and updated metadata. The data structure now explicitly includes \text\_inputs\ and \text\_outputs\ boolean fields for each model, providing clearer information about supported input and output modalities. This change ensures that applications relying on this data have accurate, up-to-date information about model capabilities and constraints.

_libs/partners/mistralai/langchain\mistralai/data · high confidence

The OpenAI partner package now includes refreshed model profile data for the \langchain\_openai\ library, adding support for newer models such as GPT-5, GPT-5.1, GPT-5.2, GPT-5.3, GPT-5.4, GPT-5.5, GPT-5.6, and GPT-6 variants (including Astra, Sol, Luna, and Terra). These profiles define capabilities like structured output, tool calling, and input types, and explicitly configure \reasoning\_effort\_levels\ (e.g., none, low, medium, high, xhigh, max) and \max\_input\_tokens\ (272,000) for the GPT-5/6 series. The data is managed via \profile\_augmentations.toml\ to allow overrides for specific models, ensuring accurate parameter handling for these latest releases.

_libs/partners/openai/langchain\openai/data · high confidence

The OpenRouter partner package's internal model profile data has been refreshed to reflect the latest model capabilities and metadata from the models.dev source. Additionally, the configuration for the OpenRouter provider has been updated to explicitly enable tool call streaming by default via the profile augmentations file.

_libs/partners/openrouter/langchain\openrouter/data · high confidence

The Anthropic partner package now includes updated model profile data for Claude Fable 5, Fable 5.1, Opus 5, Opus 5.5, Sonnet 5, and Sonnet 4.6/4.7/4.8. These profiles enable structured output and fine-grained reasoning effort levels (low, medium, high, xhigh, max) for the specified models, ensuring the library correctly exposes these capabilities to users.

_libs/partners/anthropic/langchain\anthropic/data · high confidence

The xAI partner package now includes refreshed model profile data for several new Grok models (4.20, 4.3, 4.5, 4.6, 4.7, and Build 0.1), detailing their input/output capabilities such as text, image, and PDF support. Notably, the Grok 4.3 profile has been updated to include \reasoning\_effort\_levels\ (none, low, medium, high) with a default of 'low', aligning with the core framework's new standard parameter for controlling reasoning depth.

_libs/partners/xai/langchain\xai/data · high confidence

The langchain-fireworks package has been updated to version 1.6.3, introducing a new FireworksRerank component for document reranking alongside the existing ChatFireworks, Fireworks, and FireworksEmbeddings integrations. This release migrates the underlying client to the fireworks-ai 1.x SDK and includes behavioral fixes such as dropping reasoning history blocks from responses, translating multimodal content blocks for chat completions, and ensuring proper handling of tool choices with multiple tools.

_libs/partners/fireworks/langchain\fireworks · high confidence

The \langchain-ollama\ package has been updated to version 1.1.0, introducing a new compatibility layer (\\_compat.py\) that converts LangChain v1 content blocks to the Ollama SDK format, ensuring support for text, image, and non-standard content types. This release also includes a dedicated model validation utility (\\_utils.py\) that verifies model existence and handles connection errors, and adds support for parsing URLs with embedded basic authentication credentials in the \base\_url\ parameter for both sync and async clients.

_libs/partners/ollama/langchain\ollama · high confidence

Add unit tests for MistralAI partner package; Added OpenAI test infrastructure with OAuth secret scrubbing; Added benchmark tests for agent instantiation; Added benchmark tests for import times, async callbacks, and tool schema conversion; Added empty \_\init\\_.py files for test packages; Added empty test structure for dependencies; Added fake callback handler for testing; Added fake callback handlers for unit testing; Added import tests for utilities module; Added import validation tests for docstore and smith modules; Added import validation tests for langchain\_classic schema modules; Added import validation tests for the prompts module; Added integration test package for agents; Added integration test scaffolding and fixtures; Added integration tests for ChatAnthropic and AnthropicLLM; Added integration tests for ChatGroq; Added integration tests for Elasticsearch chat message history; Added integration tests for Exa search and retrieval tools; Added integration tests for FastEmbedSparse with Qdrant; Added integration tests for Fireworks chat, LLM, and embedding models; Added integration tests for HuggingFace partners; Added integration tests for MCPAdapter protocol era handling; Added integration tests for MistralAI partner package; Added integration tests for Ollama embeddings and LLMs; Added integration tests for OpenAI and Azure OpenAI LLMs; Added integration tests for OpenAI functions and moderation chains; Added integration tests for Perplexity chat, embeddings, and search; Added integration tests for QdrantVectorStore; Added integration tests for document compressor rerankers; Added integration tests for embedding distance evaluation chains; Added integration tests for embeddings initialization; Added integration tests for the DeepSeek chat model; Added integration tests for the Qdrant vector store; Added integration tests for the generic configurable chat model initialization; Added integration tests for the langchain-openrouter provider; Added integration tests for the v1 chat model initialization; Added integration tests for xAI chat model features; Added mock Robot server for API chain testing; Added regression tests for the vector stores public API; Added sample data files for integration tests; Added serialization/deserialization snapshot tests for ChatAnthropic; Added serialization/deserialization test for ChatFireworks; Added serialization/deserialization test for ChatMistralAI; Added serialization/deserialization tests for ChatGroq; Added serialization/deserialization tests for OpenAI chat models; Added snapshot tests for ChatXAI serialization; Added snapshot tests for agent graph diagrams; Added snapshot tests for chat and prompt input schemas; Added snapshot tests for runnable serialization and graph visualization; Added snapshot tests for serialization output; Added test data module for PDF integration tests; Added test fixtures for non-UTF-8 encoding and OpenAPI specifications; Added test fixtures for prompt serialization and security validation; Added test infrastructure for Groq partner integration; Added test infrastructure for agent middleware; Added test infrastructure for cache integration tests; Added test package structure for HuggingFace integration; Added test runner documentation for Ollama integration tests; Added tests for document parser public API stability; Added tests for the dynamic import and deprecation handling API; Added unit and integration tests for model profiles CLI and summary generation; Added unit test suite for agents in langchain\_v1; Added unit test suite for langchain v1 scaffolding; Added unit tests for ChatGeneration.text and outputs module imports; Added unit tests for Document class initialization, string representation, and public API exports; Added unit tests for ExactMatch and RegexMatch string evaluators; Added unit tests for HubRunnable and OpenAIFunctionsRouter; Added unit tests for HuggingFace integration components; Added unit tests for InMemoryCache; Added unit tests for InMemoryStore; Added unit tests for InMemoryVectorStore and VectorStore utilities; Added unit tests for JSON parsing evaluators; Added unit tests for LLM base functionality, caching, and tracing; Added unit tests for LLM module imports and fake model utilities; Added unit tests for LangSmith evaluation runner utilities and string run evaluators; Added unit tests for Ollama partner integration; Added unit tests for OpenAI LLM integration; Added unit tests for OpenAI moderation middleware; Added unit tests for SelfQueryRetriever base functionality; Added unit tests for agent middleware core functionality; Added unit tests for agent middleware type safety and backwards compatibility; Added unit tests for agent output parsers; Added unit tests for agent scratchpad formatting utilities; Added unit tests for agent trajectory evaluation chain; Added unit tests for chat history deprecation and async interfaces; Added unit tests for chat model caching, rate limiting, and tracing; Added unit tests for chat model initialization and module exports; Added unit tests for core callback system behaviors; Added unit tests for core indexing components; Added unit tests for core message utilities and serialization; Added unit tests for core tracer functionality; Added unit tests for core utility functions; Added unit tests for document compressor components; Added unit tests for document loader base classes and LangSmith loader; Added unit tests for document loader imports and base schema; Added unit tests for embeddings module initialization and model parsing; Added unit tests for fake LLM and callback utilities; Added unit tests for langchain-openai; Added unit tests for langchain\_classic chains; Added unit tests for message block translators; Added unit tests for pairwise evaluation chains; Added unit tests for prompt templates and loading; Added unit tests for runnable module public API exports; Added unit tests for runnables and rate limiters; Added unit tests for serialization and deserialization in the load module; Added unit tests for string distance evaluation chains; Added unit tests for the Chroma vector store integration; Added unit tests for the DeepSeek chat model integration; Added unit tests for the Groq integration; Added unit tests for the LangChain Anthropic integration; Added unit tests for the LoggingCallbackHandler tracer; Added unit tests for the agents module; Added unit tests for the core API deprecation and beta warning utilities; Added unit tests for the criteria evaluation chain; Added unit tests for the indexing API; Added unit tests for the load module's serialization and security behaviors; Added unit tests for the new MCP adapter integration; Added unit tests for the query constructor parser; Added unit tests for the v1 chat model initialization and provider inference; Added unit tests for the xAI chat integration; Added unit tests for tools module public API; Added unit tests for v3 streaming, projections, and model profiles; Initial unit test suite for langchain-openrouter; New integration test suite for OpenAI chat models; New unit test suite for LangChain Core; New unit test suite for langchain-classic; Removed integration and unit tests for chains, LLMs, and prompts; Unit tests for OpenAI chat models; Updated test infrastructure with VCR cassette improvements.

The LangChain library has been updated to version 1.4.2. This release includes the standard package initialization and type-stub marker files for the v1 branch.

_libs/langchain\v1/langchain · high confidence

The langchain-chroma partner package has been updated to version 1.1.0. This release includes the core vector store implementation, versioning infrastructure, and type stubs for the Chroma integration, ensuring compatibility with the latest ChromaDB client features and LangChain core standards.

_libs/partners/chroma/langchain\chroma · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 37 → 69 (+31.7)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 83 → 81 (-2.3)
• Architecture 96 → 99 (+3.5)
• Maturity 46 → 72 (+26.0)
• Readiness 30 → 64 (+34.3)
• Security 25 → 66 (+41.4)

• Coverage not measured — test suite did not build
• Dimension evaluation failed
• Duplicated block (10 lines × 2) (libs/core/langchain_core/language_models/chat_model_stream.py)
• Duplicated block (10 lines × 2) (libs/core/langchain_core/language_models/chat_model_stream.py)
• Duplicated block (10 lines × 2) (libs/partners/openai/langchain_openai/chat_models/base.py)
• Duplicated block (10 lines × 2) (libs/standard-tests/langchain_tests/integration_tests/chat_models.py)
• Duplicated block (11 lines × 2) (libs/core/langchain_core/language_models/chat_model_stream.py)
• Duplicated block (11 lines × 2) (libs/core/langchain_core/language_models/llms.py)
• Duplicated block (11 lines × 2) (libs/core/langchain_core/language_models/llms.py)
• Duplicated block (11 lines × 2) (libs/core/tests/unit_tests/load/test_serializable.py)
• Duplicated block (11 lines × 2) (libs/standard-tests/langchain_tests/integration_tests/chat_models.py)
• Duplicated block (12 lines × 2) (libs/core/tests/unit_tests/language_models/test_chat_model_v3_stream.py)
• Duplicated block (13 lines × 2) (libs/core/langchain_core/runnables/base.py)
• Duplicated block (13 lines × 2) (libs/langchain/langchain_classic/agents/agent.py)
• Duplicated block (14 lines × 2) (libs/core/langchain_core/language_models/chat_models.py)
• Duplicated block (14 lines × 2) (libs/core/langchain_core/language_models/chat_models.py)
• Duplicated block (14 lines × 2) (libs/core/langchain_core/runnables/base.py)
• Duplicated block (14 lines × 2) (libs/langchain_v1/tests/unit_tests/agents/middleware/core/test_wrap_model_call.py)
• Duplicated block (14 lines × 2) (libs/partners/anthropic/langchain_anthropic/llms.py)
• Duplicated block (14 lines × 2) (libs/partners/openai/langchain_openai/llms/base.py)
• …and 48 more

• AIMessage._backwards_compat_tool_calls (cognitive 16) (libs/core/langchain_core/messages/ai.py)
• AIMessage.content_blocks (cognitive 28) (libs/core/langchain_core/messages/ai.py)
• AIMessage.content_blocks (cyclomatic 16) (libs/core/langchain_core/messages/ai.py)
• AIMessageChunk.content_blocks (cognitive 19) (libs/core/langchain_core/messages/ai.py)
• AIMessageChunk.init_server_tool_calls (cognitive 16) (libs/core/langchain_core/messages/ai.py)
• AIMessageChunk.init_tool_calls (cognitive 28) (libs/core/langchain_core/messages/ai.py)
• AIMessageChunk.init_tool_calls (cyclomatic 16) (libs/core/langchain_core/messages/ai.py)
• AgentExecutor._aiter_next_step (cognitive 20) (libs/langchain/langchain_classic/agents/agent.py)
• AgentExecutor._iter_next_step (cognitive 22) (libs/langchain/langchain_classic/agents/agent.py)
• AgentExecutorIterator.aiter (cognitive 17) (libs/langchain/langchain_classic/agents/agent_iterator.py)
• AgentExecutorIterator.iter (cognitive 16) (libs/langchain/langchain_classic/agents/agent_iterator.py)
• AnthropicLLM._format_messages (cognitive 24) (libs/partners/anthropic/langchain_anthropic/llms.py)
• AsciiCanvas.line (cognitive 19) (libs/core/langchain_core/runnables/graph_ascii.py)
• AzureChatOpenAI.validate_environment (cognitive 30) (libs/partners/openai/langchain_openai/chat_models/azure.py)
• AzureChatOpenAI.validate_environment (cyclomatic 26) (libs/partners/openai/langchain_openai/chat_models/azure.py)
• AzureOpenAI.validate_environment (cognitive 22) (libs/partners/openai/langchain_openai/llms/azure.py)
• AzureOpenAI.validate_environment (cyclomatic 20) (libs/partners/openai/langchain_openai/llms/azure.py)
• AzureOpenAIEmbeddings.validate_environment (cognitive 18) (libs/partners/openai/langchain_openai/embeddings/azure.py)
• AzureOpenAIEmbeddings.validate_environment (cyclomatic 16) (libs/partners/openai/langchain_openai/embeddings/azure.py)
• BaseChatModel._agenerate_with_cache (cognitive 68) (libs/core/langchain_core/language_models/chat_models.py)
• …and 994 more

• 300 commits — 221 feature/other, 79 fixes

• libs/partners — 177 commits
• libs/core — 51 commits
• libs/langchain_v1 — 27 commits
• libs/text-splitters — 12 commits
• libs/langchain — 6 commits
• libs/standard-tests — 6 commits
• libs/model-profiles — 5 commits
• openwiki/.claims — 5 commits
• .github/workflows — 4 commits
• (root) — 3 commits
• .github/ISSUE_TEMPLATE — 1 commit
• .github/actions — 1 commit
• .github/dependabot.yml — 1 commit
• .github/scripts — 1 commit

• fix: chore(anthropic): fix integration test cassette (#40790)
• fix: chore(langchain): fix type errors in tests (#39589)
• fix: chore(openai): fix tests (#39972)
• fix: fix(anthropic): add Opus 5.5 and GPT-6 profile augmentations (#40785)
• fix: fix(anthropic): auto-append advisor-tool-2026-03-01 beta header for advisor_20260301 tool (#39917)
• fix: fix(anthropic): auto-route with_structured_output to method="json_schema" for fable and opus 5.5 (#40766)
• fix: fix(anthropic): correct model profile data for Fable 5, Sonnet 5, Opus 4.1 (#39604)
• fix: fix(anthropic): exclude sibling directories from grep search scope (#39681)
• fix: fix(anthropic): filter invalid tool calls from v1 content (#39803)
• fix: fix(anthropic): normalize tool_search_tool_result blocks (#39621)
• fix: fix(anthropic): preserve invalid tool use blocks (#40372)
• fix: fix(anthropic): report reasoning tokens in usage metadata (#39590)
• fix: fix(core): abbreviate long tool IDs in XML buffer strings (#40792)
• fix: fix(core): accept non-dict Mapping values in mustache templates (#39680)
• fix: fix(core): allow deserializing RunnablePick (#39753)
• fix: fix(core): avoid mutation in bedrock converse standard content (#40022)
• fix: fix(core): avoid mutation in google-genai standard content (#40023)
• fix: fix(core): clear usage metadata callback on exceptions in context manager (#39616)
• fix: fix(core): fail fast when tool schemas can't resolve forward refs during serialization (#39570)
• fix: fix(core): finalize chain-group runs on BaseException (#39699)
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

langchain-ai/langchain was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.