Merge branch 'master' into copilot/fix-31653

Co-authored-by: mdrxy <61371264+mdrxy@users.noreply.github.com>

.devcontainer/README.md

@@ -5,31 +5,26 @@ This project includes a [dev container](https://containers.dev/), which lets you
 You can use the dev container configuration in this folder to build and run the app without needing to install any of its tools locally! You can use it in [GitHub Codespaces](https://github.com/features/codespaces) or the [VS Code Dev Containers extension](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers).
 
 ## GitHub Codespaces
-
 [![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/langchain-ai/langchain)
 
 You may use the button above, or follow these steps to open this repo in a Codespace:
-
-1. Click the **Code** drop-down menu at the top of <https://github.com/langchain-ai/langchain>.
+1. Click the **Code** drop-down menu at the top of https://github.com/langchain-ai/langchain.
 1. Click on the **Codespaces** tab.
 1. Click **Create codespace on master**.
 
 For more info, check out the [GitHub documentation](https://docs.github.com/en/free-pro-team@latest/github/developing-online-with-codespaces/creating-a-codespace#creating-a-codespace).
-
+  
 ## VS Code Dev Containers
-
 [![Open in Dev Containers](https://img.shields.io/static/v1?label=Dev%20Containers&message=Open&color=blue&logo=visualstudiocode)](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/langchain-ai/langchain)
 
-> [!NOTE]
-> If you click the link above you will open the main repo (`langchain-ai/langchain`) and *not* your local cloned repo. This is fine if you only want to run and test the library, but if you want to contribute you can use the link below and replace with your username and cloned repo name:
-
-```txt
-https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/&lt;YOUR_USERNAME&gt;/&lt;YOUR_CLONED_REPO_NAME&gt;
+Note: If you click the link above you will open the main repo (langchain-ai/langchain) and not your local cloned repo. This is fine if you only want to run and test the library, but if you want to contribute you can use the  link below and replace with your username and cloned repo name: 
 ```
+https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/<yourusername>/<yourclonedreponame>
 
+```
 Then you will have a local cloned repo where you can contribute and then create pull requests.
 
-If you already have VS Code and Docker installed, you can use the button above to get started. This will use VSCode to automatically install the Dev Containers extension if needed, clone the source code into a container volume, and spin up a dev container for use.
+If you already have VS Code and Docker installed, you can use the button above to get started. This will cause VS Code to automatically install the Dev Containers extension if needed, clone the source code into a container volume, and spin up a dev container for use.
 
 Alternatively you can also follow these steps to open this repo in a container using the VS Code Dev Containers extension:
 
@@ -45,5 +40,5 @@ You can learn more in the [Dev Containers documentation](https://code.visualstud
 
 ## Tips and tricks
 
-- If you are working with the same repository folder in a container and Windows, you'll want consistent line endings (otherwise you may see hundreds of changes in the SCM view). The `.gitattributes` file in the root of this repo will disable line ending conversion and should prevent this. See [tips and tricks](https://code.visualstudio.com/docs/devcontainers/tips-and-tricks#_resolving-git-line-ending-issues-in-containers-resulting-in-many-modified-files) for more info.
-- If you'd like to review the contents of the image used in this dev container, you can check it out in the [devcontainers/images](https://github.com/devcontainers/images/tree/main/src/python) repo.
+* If you are working with the same repository folder in a container and Windows, you'll want consistent line endings (otherwise you may see hundreds of changes in the SCM view). The `.gitattributes` file in the root of this repo will disable line ending conversion and should prevent this. See [tips and tricks](https://code.visualstudio.com/docs/devcontainers/tips-and-tricks#_resolving-git-line-ending-issues-in-containers-resulting-in-many-modified-files) for more info.
+* If you'd like to review the contents of the image used in this dev container, you can check it out in the [devcontainers/images](https://github.com/devcontainers/images/tree/main/src/python) repo.

.devcontainer/devcontainer.json

@@ -1,58 +1,36 @@
 // For format details, see https://aka.ms/devcontainer.json. For config options, see the
 // README at: https://github.com/devcontainers/templates/tree/main/src/docker-existing-docker-compose
 {
-  // Name for the dev container
-  "name": "langchain",
-  // Point to a Docker Compose file
-  "dockerComposeFile": "./docker-compose.yaml",
-  // Required when using Docker Compose. The name of the service to connect to once running
-  "service": "langchain",
-  // The optional 'workspaceFolder' property is the path VS Code should open by default when
-  // connected. This is typically a file mount in .devcontainer/docker-compose.yml
-  "workspaceFolder": "/workspaces/langchain",
-  "mounts": [
-    "source=langchain-workspaces,target=/workspaces/langchain,type=volume"
-  ],
-  // Prevent the container from shutting down
-  "overrideCommand": true,
-  // Features to add to the dev container. More info: https://containers.dev/features
-  "features": {
-    "ghcr.io/devcontainers/features/git:1": {},
-    "ghcr.io/devcontainers/features/github-cli:1": {}
-  },
-  "containerEnv": {
-    "UV_LINK_MODE": "copy"
-  },
-  // Use 'forwardPorts' to make a list of ports inside the container available locally.
-  // "forwardPorts": [],
-  // Run commands after the container is created
-  "postCreateCommand": "uv sync && echo 'LangChain (Python) dev environment ready!'",
-  // Configure tool-specific properties.
-  "customizations": {
-    "vscode": {
-      "extensions": [
-        "ms-python.python",
-        "ms-python.debugpy",
-        "ms-python.mypy-type-checker",
-        "ms-python.isort",
-        "unifiedjs.vscode-mdx",
-        "davidanson.vscode-markdownlint",
-        "ms-toolsai.jupyter",
-        "GitHub.copilot",
-        "GitHub.copilot-chat"
-      ],
-      "settings": {
-        "python.defaultInterpreterPath": ".venv/bin/python",
-        "python.formatting.provider": "none",
-        "[python]": {
-          "editor.formatOnSave": true,
-          "editor.codeActionsOnSave": {
-            "source.organizeImports": true
-          }
-        }
-      }
-    }
-  }
-  // Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
-  // "remoteUser": "root"
+	// Name for the dev container
+	"name": "langchain",
+
+	// Point to a Docker Compose file
+	"dockerComposeFile": "./docker-compose.yaml",
+
+	// Required when using Docker Compose. The name of the service to connect to once running
+	"service": "langchain",
+
+	// The optional 'workspaceFolder' property is the path VS Code should open by default when
+	// connected. This is typically a file mount in .devcontainer/docker-compose.yml
+	"workspaceFolder": "/workspaces/langchain",
+
+	// Prevent the container from shutting down
+	"overrideCommand": true
+
+	// Features to add to the dev container. More info: https://containers.dev/features
+	// "features": {
+	// 	"ghcr.io/devcontainers-contrib/features/poetry:2": {}
+	// }
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+
+	// Uncomment the next line to run commands after the container is created.
+	// "postCreateCommand": "cat /etc/os-release",
+
+	// Configure tool-specific properties.
+	// "customizations": {},
+
+	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
+	// "remoteUser": "root"
 }

.devcontainer/docker-compose.yaml

@@ -4,9 +4,26 @@ services:
     build:
       dockerfile: libs/langchain/dev.Dockerfile
       context: ..
-
+    volumes:
+      # Update this to wherever you want VS Code to mount the folder of your project
+      - ..:/workspaces/langchain:cached
     networks:
       - langchain-network
+  #   environment:
+  #     MONGO_ROOT_USERNAME: root
+  #     MONGO_ROOT_PASSWORD: example123
+  #   depends_on:
+  #     - mongo   
+  # mongo:
+  #   image: mongo
+  #   restart: unless-stopped
+  #   environment:
+  #     MONGO_INITDB_ROOT_USERNAME: root
+  #     MONGO_INITDB_ROOT_PASSWORD: example123
+  #   ports:
+  #     - "27017:27017"
+  #   networks:
+  #     - langchain-network
 
 networks:
   langchain-network:

.editorconfig

@@ -1,52 +0,0 @@
-# top-most EditorConfig file
-root = true
-
-# All files
-[*]
-charset = utf-8
-end_of_line = lf
-insert_final_newline = true
-trim_trailing_whitespace = true
-
-# Python files
-[*.py]
-indent_style = space
-indent_size = 4
-max_line_length = 88
-
-# JSON files
-[*.json]
-indent_style = space
-indent_size = 2
-
-# YAML files
-[*.{yml,yaml}]
-indent_style = space
-indent_size = 2
-
-# Markdown files
-[*.md]
-indent_style = space
-indent_size = 2
-trim_trailing_whitespace = false
-
-# Configuration files
-[*.{toml,ini,cfg}]
-indent_style = space
-indent_size = 4
-
-# Shell scripts
-[*.sh]
-indent_style = space
-indent_size = 2
-
-# Makefile
-[Makefile]
-indent_style = tab
-indent_size = 4
-
-# Jupyter notebooks
-[*.ipynb]
-# Jupyter may include trailing whitespace in cell
-# outputs that's semantically meaningful
-trim_trailing_whitespace = false

.github/CODE_OF_CONDUCT.md

@@ -129,4 +129,4 @@ For answers to common questions about this code of conduct, see the FAQ at
 [v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
 [Mozilla CoC]: https://github.com/mozilla/diversity
 [FAQ]: https://www.contributor-covenant.org/faq
-[translations]: https://www.contributor-covenant.org/translations
+[translations]: https://www.contributor-covenant.org/translations

.github/CONTRIBUTING.md

@@ -7,4 +7,4 @@ To learn how to contribute to LangChain, please follow the [contribution guide h
 
 ## New features
 
-For new features, please start a new [discussion on our forum](https://forum.langchain.com/), where the maintainers will help with scoping out the necessary changes.
+For new features, please start a new [discussion](https://forum.langchain.com/), where the maintainers will help with scoping out the necessary changes.

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -5,7 +5,7 @@ body:
   - type: markdown
     attributes:
       value: |
-        Thank you for taking the time to file a bug report.
+        Thank you for taking the time to file a bug report. 
 
         Use this to report BUGS in LangChain. For usage questions, feature requests and general design questions, please use the [LangChain Forum](https://forum.langchain.com/).
 
@@ -50,7 +50,7 @@ body:
 
         If a maintainer can copy it, run it, and see it right away, there's a much higher chance that you'll be able to get help.
 
-        **Important!**
+        **Important!** 
 
         * Avoid screenshots when possible, as they are hard to read and (more importantly) don't allow others to copy-and-paste your code.
         * Reduce your code to the minimum required to reproduce the issue if possible. This makes it much easier for others to help you.
@@ -58,14 +58,14 @@ body:
         * INCLUDE the language label (e.g. `python`) after the first three backticks to enable syntax highlighting. (e.g., ```python rather than ```).
 
       placeholder: |
-        The following code:
+        The following code: 
 
         ```python
         from langchain_core.runnables import RunnableLambda
 
         def bad_code(inputs) -> int:
           raise NotImplementedError('For demo purpose')
-
+          
           chain = RunnableLambda(bad_code)
           chain.invoke('Hello!')
         ```

.github/ISSUE_TEMPLATE/documentation.yml

@@ -14,7 +14,7 @@ body:
 
         Do **NOT** use this to ask usage questions or reporting issues with your code.
 
-        If you have usage questions or need help solving some problem,
+        If you have usage questions or need help solving some problem, 
         please use the [LangChain Forum](https://forum.langchain.com/).
 
         If you're in the wrong place, here are some helpful links to find a better

.github/ISSUE_TEMPLATE/privileged.yml

@@ -8,7 +8,7 @@ body:
 
         If you are not a LangChain maintainer or were not asked directly by a maintainer to create an issue, then please start the conversation on the [LangChain Forum](https://forum.langchain.com/) instead.
 
-        You are a LangChain maintainer if you maintain any of the packages inside of the LangChain repository
+        You are a LangChain maintainer if you maintain any of the packages inside of the LangChain repository 
         or are a regular contributor to LangChain with previous merged pull requests.
   - type: checkboxes
     id: privileged

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,5 +1,3 @@
-(Replace this entire block of text)
-
 Thank you for contributing to LangChain! Follow these steps to mark your pull request as ready for review. **If any of these steps are not completed, your PR will not be considered for review.**
 
 - [ ] **PR title**: Follows the format: {TYPE}({SCOPE}): {DESCRIPTION}
@@ -11,13 +9,14 @@ Thank you for contributing to LangChain! Follow these steps to mark your pull re
     - feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert, release
   - Allowed `{SCOPE}` values (optional):
     - core, cli, langchain, standard-tests, docs, anthropic, chroma, deepseek, exa, fireworks, groq, huggingface, mistralai, nomic, ollama, openai, perplexity, prompty, qdrant, xai
-  - *Note:* the `{DESCRIPTION}` must not start with an uppercase letter.
+  - Note: the `{DESCRIPTION}` must not start with an uppercase letter.
   - Once you've written the title, please delete this checklist item; do not include it in the PR.
 
 - [ ] **PR message**: ***Delete this entire checklist*** and replace with
   - **Description:** a description of the change. Include a [closing keyword](https://docs.github.com/en/issues/tracking-your-work-with-issues/using-issues/linking-a-pull-request-to-an-issue#linking-a-pull-request-to-an-issue-using-a-keyword) if applicable to a relevant issue.
   - **Issue:** the issue # it fixes, if applicable (e.g. Fixes #123)
   - **Dependencies:** any dependencies required for this change
+  - **Twitter handle:** if your PR gets announced, and you'd like a mention, we'll gladly shout you out!
 
 - [ ] **Add tests and docs**: If you're adding a new integration, you must include:
   1. A test for the integration, preferably unit tests that do not rely on network access,
@@ -27,7 +26,7 @@ Thank you for contributing to LangChain! Follow these steps to mark your pull re
 
 Additional guidelines:
 
-- Most PRs should not touch more than one package.
-- Please do not add dependencies to `pyproject.toml` files (even optional ones) unless they are **required** for unit tests.
-- Changes should be backwards compatible.
 - Make sure optional dependencies are imported within a function.
+- Please do not add dependencies to `pyproject.toml` files (even optional ones) unless they are **required** for unit tests.
+- Most PRs should not touch more than one package.
+- Changes should be backwards compatible.

.github/actions/people/Dockerfile

@@ -4,4 +4,4 @@ RUN pip install httpx PyGithub "pydantic==2.0.2" pydantic-settings "pyyaml>=5.3.
 
 COPY ./app /app
 
-CMD ["python", "/app/main.py"]
+CMD ["python", "/app/main.py"]

.github/actions/people/action.yml

@@ -4,8 +4,8 @@ description: "Generate the data for the LangChain People page"
 author: "Jacob Lee <jacob@langchain.dev>"
 inputs:
   token:
-    description: "User token, to read the GitHub API. Can be passed in using {{ secrets.LANGCHAIN_PEOPLE_GITHUB_TOKEN }}"
+    description: 'User token, to read the GitHub API. Can be passed in using {{ secrets.LANGCHAIN_PEOPLE_GITHUB_TOKEN }}'
     required: true
 runs:
-  using: "docker"
-  image: "Dockerfile"
+  using: 'docker'
+  image: 'Dockerfile'

.github/copilot-instructions.md

@@ -1,116 +1,72 @@
-# Global Development Guidelines for LangChain Projects
+### 1. Avoid Breaking Changes (Stable Public Interfaces)
 
-## Core Development Principles
+* Carefully preserve **function signatures**, argument positions, and names for any exported/public methods.
+* Be cautious when **renaming**, **removing**, or **reordering** arguments — even small changes can break downstream consumers.
+* Use keyword-only arguments or clearly mark experimental features to isolate unstable APIs.
 
-### 1. Maintain Stable Public Interfaces ⚠️ CRITICAL
-
-**Always attempt to preserve function signatures, argument positions, and names for exported/public methods.**
-
-❌ **Bad - Breaking Change:**
+Bad:
 
 ```python
 def get_user(id, verbose=False):  # Changed from `user_id`
-    pass
 ```
 
-✅ **Good - Stable Interface:**
+Good:
 
 ```python
-def get_user(user_id: str, verbose: bool = False) -> User:
-    """Retrieve user by ID with optional verbose output."""
-    pass
+def get_user(user_id: str, verbose: bool = False):  # Maintains stable interface
 ```
 
-**Before making ANY changes to public APIs:**
+🧠 *Ask yourself:* “Would this change break someone's code if they used it last week?”
 
-- Check if the function/class is exported in `__init__.py`
-- Look for existing usage patterns in tests and examples
-- Use keyword-only arguments for new parameters: `*, new_param: str = "default"`
-- Mark experimental features clearly with docstring warnings (using reStructuredText, like `.. warning::`)
+---
 
-🧠 *Ask yourself:* "Would this change break someone's code if they used it last week?"
+### 2. Simplify Code and Use Clear Variable Names
 
-### 2. Code Quality Standards
+* Prefer descriptive, **self-explanatory variable names**. Avoid overly short or cryptic identifiers.
+* Break up overly long or deeply nested functions for **readability and maintainability**.
+* Avoid unnecessary abstraction or premature optimization.
+* All generated Python code must include type hints.
 
-**All Python code MUST include type hints and return types.**
-
-❌ **Bad:**
+Bad:
 
 ```python
 def p(u, d):
     return [x for x in u if x not in d]
 ```
 
-✅ **Good:**
+Good:
 
 ```python
-def filter_unknown_users(users: list[str], known_users: set[str]) -> list[str]:
-    """Filter out users that are not in the known users set.
-
-    Args:
-        users: List of user identifiers to filter.
-        known_users: Set of known/valid user identifiers.
-
-    Returns:
-        List of users that are not in the known_users set.
-    """
+def filter_unknown_users(users: List[str], known_users: Set[str]) -> List[str]:
     return [user for user in users if user not in known_users]
 ```
 
-**Style Requirements:**
+---
 
-- Use descriptive, **self-explanatory variable names**. Avoid overly short or cryptic identifiers.
-- Attempt to break up complex functions (>20 lines) into smaller, focused functions where it makes sense
-- Avoid unnecessary abstraction or premature optimization
-- Follow existing patterns in the codebase you're modifying
+### 3. Ensure Unit Tests Cover New and Updated Functionality
 
-### 3. Testing Requirements
+* Every new feature or bugfix should be **covered by a unit test**.
+* Test edge cases and failure conditions.
+* Use `pytest`, `unittest`, or the project’s existing framework consistently.
 
-**Every new feature or bugfix MUST be covered by unit tests.**
+Checklist:
 
-**Test Organization:**
+* [ ] Does the test suite fail if your new logic is broken?
+* [ ] Are all expected behaviors exercised (happy path, invalid input, etc)?
+* [ ] Do tests use fixtures or mocks where needed?
 
-- Unit tests: `tests/unit_tests/` (no network calls allowed)
-- Integration tests: `tests/integration_tests/` (network calls permitted)
-- Use `pytest` as the testing framework
+---
 
-**Test Quality Checklist:**
+### 4. Look for Suspicious or Risky Code
 
-- [ ] Tests fail when your new logic is broken
-- [ ] Happy path is covered
-- [ ] Edge cases and error conditions are tested
-- [ ] Use fixtures/mocks for external dependencies
-- [ ] Tests are deterministic (no flaky tests)
+* Watch out for:
 
-Checklist questions:
+  * Use of `eval()`, `exec()`, or `pickle` on user-controlled input.
+  * Silent failure modes (`except: pass`).
+  * Unreachable code or commented-out blocks.
+  * Race conditions or resource leaks (file handles, sockets, threads).
 
-- [ ] Does the test suite fail if your new logic is broken?
-- [ ] Are all expected behaviors exercised (happy path, invalid input, etc)?
-- [ ] Do tests use fixtures or mocks where needed?
-
-```python
-def test_filter_unknown_users():
-    """Test filtering unknown users from a list."""
-    users = ["alice", "bob", "charlie"]
-    known_users = {"alice", "bob"}
-
-    result = filter_unknown_users(users, known_users)
-
-    assert result == ["charlie"]
-    assert len(result) == 1
-```
-
-### 4. Security and Risk Assessment
-
-**Security Checklist:**
-
-- No `eval()`, `exec()`, or `pickle` on user-controlled input
-- Proper exception handling (no bare `except:`) and use a `msg` variable for error messages
-- Remove unreachable/commented code before committing
-- Race conditions or resource leaks (file handles, sockets, threads).
-- Ensure proper resource cleanup (file handles, connections)
-
-❌ **Bad:**
+Bad:
 
 ```python
 def load_config(path):
@@ -118,7 +74,7 @@ def load_config(path):
         return eval(f.read())  # ⚠️ Never eval config
 ```
 
-✅ **Good:**
+Good:
 
 ```python
 import json
@@ -128,198 +84,68 @@ def load_config(path: str) -> dict:
         return json.load(f)
 ```
 
-### 5. Documentation Standards
+---
 
-**Use Google-style docstrings with Args section for all public functions.**
+### 5. Use Google-Style Docstrings (with Args section)
 
-❌ **Insufficient Documentation:**
+* All public functions should include a **Google-style docstring**.
+* Include an `Args:` section where relevant.
+* Types should NOT be written in the docstring — use type hints instead.
+
+Bad:
 
 ```python
 def send_email(to, msg):
     """Send an email to a recipient."""
 ```
 
-✅ **Complete Documentation:**
+Good:
 
 ```python
-def send_email(to: str, msg: str, *, priority: str = "normal") -> bool:
+def send_email(to: str, msg: str) -> None:
     """
-    Send an email to a recipient with specified priority.
+    Sends an email to a recipient.
 
     Args:
         to: The email address of the recipient.
-        msg: The message body to send.
-        priority: Email priority level (``'low'``, ``'normal'``, ``'high'``).
-
-    Returns:
-        True if email was sent successfully, False otherwise.
-
-    Raises:
-        InvalidEmailError: If the email address format is invalid.
-        SMTPConnectionError: If unable to connect to email server.
+        msg: The message body.
     """
 ```
 
-**Documentation Guidelines:**
-
-- Types go in function signatures, NOT in docstrings
-- Focus on "why" rather than "what" in descriptions
-- Document all parameters, return values, and exceptions
-- Keep descriptions concise but clear
-- Use reStructuredText for docstrings to enable rich formatting
-
 📌 *Tip:* Keep descriptions concise but clear. Only document return values if non-obvious.
 
-### 6. Architectural Improvements
-
-**When you encounter code that could be improved, suggest better designs:**
-
-❌ **Poor Design:**
-
-```python
-def process_data(data, db_conn, email_client, logger):
-    # Function doing too many things
-    validated = validate_data(data)
-    result = db_conn.save(validated)
-    email_client.send_notification(result)
-    logger.log(f"Processed {len(data)} items")
-    return result
-```
-
-✅ **Better Design:**
-
-```python
-@dataclass
-class ProcessingResult:
-    """Result of data processing operation."""
-    items_processed: int
-    success: bool
-    errors: List[str] = field(default_factory=list)
-
-class DataProcessor:
-    """Handles data validation, storage, and notification."""
-
-    def __init__(self, db_conn: Database, email_client: EmailClient):
-        self.db = db_conn
-        self.email = email_client
-
-    def process(self, data: List[dict]) -> ProcessingResult:
-        """Process and store data with notifications."""
-        validated = self._validate_data(data)
-        result = self.db.save(validated)
-        self._notify_completion(result)
-        return result
-```
-
-**Design Improvement Areas:**
-
-If there's a **cleaner**, **more scalable**, or **simpler** design, highlight it and suggest improvements that would:
-
-- Reduce code duplication through shared utilities
-- Make unit testing easier
-- Improve separation of concerns (single responsibility)
-- Make unit testing easier through dependency injection
-- Add clarity without adding complexity
-- Prefer dataclasses for structured data
-
-## Development Tools & Commands
-
-### Package Management
-
-```bash
-# Add package
-uv add package-name
-
-# Sync project dependencies
-uv sync
-uv lock
-```
-
-### Testing
-
-```bash
-# Run unit tests (no network)
-make test
-
-# Don't run integration tests, as API keys must be set
-
-# Run specific test file
-uv run --group test pytest tests/unit_tests/test_specific.py
-```
-
-### Code Quality
-
-```bash
-# Lint code
-make lint
-
-# Format code
-make format
-
-# Type checking
-uv run --group lint mypy .
-```
-
-### Dependency Management Patterns
-
-**Local Development Dependencies:**
-
-```toml
-[tool.uv.sources]
-langchain-core = { path = "../core", editable = true }
-langchain-tests = { path = "../standard-tests", editable = true }
-```
-
-**For tools, use the `@tool` decorator from `langchain_core.tools`:**
-
-```python
-from langchain_core.tools import tool
-
-@tool
-def search_database(query: str) -> str:
-    """Search the database for relevant information.
-
-    Args:
-        query: The search query string.
-    """
-    # Implementation here
-    return results
-```
-
-## Commit Standards
-
-**Use Conventional Commits format for PR titles:**
-
-- `feat(core): add multi-tenant support`
-- `fix(cli): resolve flag parsing error`
-- `docs: update API usage examples`
-- `docs(openai): update API usage examples`
-
-## Framework-Specific Guidelines
-
-- Follow the existing patterns in `langchain-core` for base abstractions
-- Use `langchain_core.callbacks` for execution tracking
-- Implement proper streaming support where applicable
-- Avoid deprecated components like legacy `LLMChain`
-
-### Partner Integrations
-
-- Follow the established patterns in existing partner libraries
-- Implement standard interfaces (`BaseChatModel`, `BaseEmbeddings`, etc.)
-- Include comprehensive integration tests
-- Document API key requirements and authentication
-
 ---
 
-## Quick Reference Checklist
+### 6. Propose Better Designs When Applicable
 
-Before submitting code changes:
+* If there's a **cleaner**, **more scalable**, or **simpler** design, highlight it.
+* Suggest improvements, even if they require some refactoring — especially if the new code would:
 
-- [ ] **Breaking Changes**: Verified no public API changes
-- [ ] **Type Hints**: All functions have complete type annotations
-- [ ] **Tests**: New functionality is fully tested
-- [ ] **Security**: No dangerous patterns (eval, silent failures, etc.)
-- [ ] **Documentation**: Google-style docstrings for public functions
-- [ ] **Code Quality**: `make lint` and `make format` pass
-- [ ] **Architecture**: Suggested improvements where applicable
-- [ ] **Commit Message**: Follows Conventional Commits format
+  * Reduce duplication
+  * Make unit testing easier
+  * Improve separation of concerns
+  * Add clarity without adding complexity
+
+Instead of:
+
+```python
+def save(data, db_conn):
+    # manually serializes fields
+```
+
+You might suggest:
+
+```python
+# Suggest using dataclasses or Pydantic for automatic serialization and validation
+```
+
+### 7. Misc
+
+* When suggesting package installation commands, use `uv pip install` as this project uses `uv`.
+* When creating tools for agents, use the @tool decorator from langchain_core.tools. The tool's docstring serves as its functional description for the agent.
+* Avoid suggesting deprecated components, such as the legacy LLMChain.
+* We use Conventional Commits format for pull request titles. Example PR titles:
+    * feat(core): add multi‐tenant support
+    * fix(cli): resolve flag parsing error
+    * docs: update API usage examples
+    * docs(openai): update API usage examples

.github/scripts/check_diff.py

@@ -3,18 +3,19 @@ import json
 import os
 import sys
 from collections import defaultdict
-from pathlib import Path
 from typing import Dict, List, Set
-
+from pathlib import Path
 import tomllib
-from get_min_versions import get_min_version_from_toml
+
 from packaging.requirements import Requirement
 
+from get_min_versions import get_min_version_from_toml
+
+
 LANGCHAIN_DIRS = [
     "libs/core",
     "libs/text-splitters",
     "libs/langchain",
-    "libs/langchain_v1",
 ]
 
 # when set to True, we are ignoring core dependents
@@ -36,7 +37,7 @@ IGNORED_PARTNERS = [
 ]
 
 PY_312_MAX_PACKAGES = [
-    "libs/partners/chroma",  # https://github.com/chroma-core/chroma/issues/4382
+    "libs/partners/chroma", # https://github.com/chroma-core/chroma/issues/4382
 ]
 
 
@@ -83,9 +84,9 @@ def dependents_graph() -> dict:
                 for depline in extended_deps:
                     if depline.startswith("-e "):
                         # editable dependency
-                        assert depline.startswith("-e ../partners/"), (
-                            "Extended test deps should only editable install partner packages"
-                        )
+                        assert depline.startswith(
+                            "-e ../partners/"
+                        ), "Extended test deps should only editable install partner packages"
                         partner = depline.split("partners/")[1]
                         dep = f"langchain-{partner}"
                     else:
@@ -132,8 +133,6 @@ def _get_configs_for_single_dir(job: str, dir_: str) -> List[Dict[str, str]]:
 
     elif dir_ == "libs/langchain" and job == "extended-tests":
         py_versions = ["3.9", "3.13"]
-    elif dir_ == "libs/langchain_v1":
-        py_versions = ["3.10", "3.13"]
 
     elif dir_ == ".":
         # unable to install with 3.13 because tokenizers doesn't support 3.13 yet
@@ -271,7 +270,7 @@ if __name__ == "__main__":
                     dirs_to_run["extended-test"].add(dir_)
         elif file.startswith("libs/standard-tests"):
             # TODO: update to include all packages that rely on standard-tests (all partner packages)
-            # Note: won't run on external repo partners
+            # note: won't run on external repo partners
             dirs_to_run["lint"].add("libs/standard-tests")
             dirs_to_run["test"].add("libs/standard-tests")
             dirs_to_run["lint"].add("libs/cli")
@@ -285,7 +284,7 @@ if __name__ == "__main__":
         elif file.startswith("libs/cli"):
             dirs_to_run["lint"].add("libs/cli")
             dirs_to_run["test"].add("libs/cli")
-
+            
         elif file.startswith("libs/partners"):
             partner_dir = file.split("/")[2]
             if os.path.isdir(f"libs/partners/{partner_dir}") and [
@@ -303,10 +302,7 @@ if __name__ == "__main__":
                 f"Unknown lib: {file}. check_diff.py likely needs "
                 "an update for this new library!"
             )
-        elif file.startswith("docs/") or file in [
-            "pyproject.toml",
-            "uv.lock",
-        ]:  # docs or root uv files
+        elif file.startswith("docs/") or file in ["pyproject.toml", "uv.lock"]: # docs or root uv files
             docs_edited = True
             dirs_to_run["lint"].add(".")
 

.github/scripts/check_prerelease_dependencies.py

@@ -1,5 +1,4 @@
 import sys
-
 import tomllib
 
 if __name__ == "__main__":

.github/scripts/get_min_versions.py

@@ -1,5 +1,5 @@
-import sys
 from collections import defaultdict
+import sys
 from typing import Optional
 
 if sys.version_info >= (3, 11):
@@ -8,13 +8,17 @@ else:
     # for python 3.10 and below, which doesnt have stdlib tomllib
     import tomli as tomllib
 
-import re
-from typing import List
-
-import requests
 from packaging.requirements import Requirement
 from packaging.specifiers import SpecifierSet
-from packaging.version import Version, parse
+from packaging.version import Version
+
+
+import requests
+from packaging.version import parse
+from typing import List
+
+import re
+
 
 MIN_VERSION_LIBS = [
     "langchain-core",
@@ -68,13 +72,11 @@ def get_minimum_version(package_name: str, spec_string: str) -> Optional[str]:
     spec_string = re.sub(r"\^0\.0\.(\d+)", r"0.0.\1", spec_string)
     # rewrite occurrences of ^0.y.z to >=0.y.z,<0.y+1 (can be anywhere in constraint string)
     for y in range(1, 10):
-        spec_string = re.sub(
-            rf"\^0\.{y}\.(\d+)", rf">=0.{y}.\1,<0.{y + 1}", spec_string
-        )
+        spec_string = re.sub(rf"\^0\.{y}\.(\d+)", rf">=0.{y}.\1,<0.{y+1}", spec_string)
     # rewrite occurrences of ^x.y.z to >=x.y.z,<x+1.0.0 (can be anywhere in constraint string)
     for x in range(1, 10):
         spec_string = re.sub(
-            rf"\^{x}\.(\d+)\.(\d+)", rf">={x}.\1.\2,<{x + 1}", spec_string
+            rf"\^{x}\.(\d+)\.(\d+)", rf">={x}.\1.\2,<{x+1}", spec_string
         )
 
     spec_set = SpecifierSet(spec_string)
@@ -167,12 +169,12 @@ def check_python_version(version_string, constraint_string):
     # rewrite occurrences of ^0.y.z to >=0.y.z,<0.y+1.0 (can be anywhere in constraint string)
     for y in range(1, 10):
         constraint_string = re.sub(
-            rf"\^0\.{y}\.(\d+)", rf">=0.{y}.\1,<0.{y + 1}.0", constraint_string
+            rf"\^0\.{y}\.(\d+)", rf">=0.{y}.\1,<0.{y+1}.0", constraint_string
         )
     # rewrite occurrences of ^x.y.z to >=x.y.z,<x+1.0.0 (can be anywhere in constraint string)
     for x in range(1, 10):
         constraint_string = re.sub(
-            rf"\^{x}\.0\.(\d+)", rf">={x}.0.\1,<{x + 1}.0.0", constraint_string
+            rf"\^{x}\.0\.(\d+)", rf">={x}.0.\1,<{x+1}.0.0", constraint_string
         )
 
     try:

.github/scripts/prep_api_docs_build.py

@@ -3,10 +3,9 @@
 
 import os
 import shutil
-from pathlib import Path
-from typing import Any, Dict
-
 import yaml
+from pathlib import Path
+from typing import Dict, Any
 
 
 def load_packages_yaml() -> Dict[str, Any]:
@@ -29,6 +28,7 @@ def get_target_dir(package_name: str) -> Path:
 def clean_target_directories(packages: list) -> None:
     """Remove old directories that will be replaced."""
     for package in packages:
+
         target_dir = get_target_dir(package["name"])
         if target_dir.exists():
             print(f"Removing {target_dir}")
@@ -38,6 +38,7 @@ def clean_target_directories(packages: list) -> None:
 def move_libraries(packages: list) -> None:
     """Move libraries from their source locations to the target directories."""
     for package in packages:
+
         repo_name = package["repo"].split("/")[1]
         source_path = package["path"]
         target_dir = get_target_dir(package["name"])
@@ -67,33 +68,21 @@ def main():
         package_yaml = load_packages_yaml()
 
         # Clean target directories
-        clean_target_directories(
-            [
-                p
-                for p in package_yaml["packages"]
-                if (
-                    p["repo"].startswith("langchain-ai/") or p.get("include_in_api_ref")
-                )
-                and p["repo"] != "langchain-ai/langchain"
-                and p["name"]
-                != "langchain-ai21"  # Skip AI21 due to dependency conflicts
-            ]
-        )
+        clean_target_directories([
+            p
+            for p in package_yaml["packages"]
+            if (p["repo"].startswith("langchain-ai/") or p.get("include_in_api_ref"))
+            and p["repo"] != "langchain-ai/langchain"
+        ])
 
         # Move libraries to their new locations
-        move_libraries(
-            [
-                p
-                for p in package_yaml["packages"]
-                if not p.get("disabled", False)
-                and (
-                    p["repo"].startswith("langchain-ai/") or p.get("include_in_api_ref")
-                )
-                and p["repo"] != "langchain-ai/langchain"
-                and p["name"]
-                != "langchain-ai21"  # Skip AI21 due to dependency conflicts
-            ]
-        )
+        move_libraries([
+            p
+            for p in package_yaml["packages"]
+            if not p.get("disabled", False)
+            and (p["repo"].startswith("langchain-ai/") or p.get("include_in_api_ref"))
+            and p["repo"] != "langchain-ai/langchain"
+        ])
 
         # Delete ones without a pyproject.toml
         for partner in Path("langchain/libs/partners").iterdir():

.github/tools/git-restore-mtime

@@ -81,93 +81,56 @@ import time
 __version__ = "2022.12+dev"
 
 # Update symlinks only if the platform supports not following them
-UPDATE_SYMLINKS = bool(os.utime in getattr(os, "supports_follow_symlinks", []))
+UPDATE_SYMLINKS = bool(os.utime in getattr(os, 'supports_follow_symlinks', []))
 
 # Call os.path.normpath() only if not in a POSIX platform (Windows)
-NORMALIZE_PATHS = os.path.sep != "/"
+NORMALIZE_PATHS = (os.path.sep != '/')
 
 # How many files to process in each batch when re-trying merge commits
 STEPMISSING = 100
 
 # (Extra) keywords for the os.utime() call performed by touch()
-UTIME_KWS = {} if not UPDATE_SYMLINKS else {"follow_symlinks": False}
+UTIME_KWS = {} if not UPDATE_SYMLINKS else {'follow_symlinks': False}
 
 
 # Command-line interface ######################################################
 
-
 def parse_args():
-    parser = argparse.ArgumentParser(description=__doc__.split("\n---")[0])
+    parser = argparse.ArgumentParser(
+        description=__doc__.split('\n---')[0])
 
     group = parser.add_mutually_exclusive_group()
-    group.add_argument(
-        "--quiet",
-        "-q",
-        dest="loglevel",
-        action="store_const",
-        const=logging.WARNING,
-        default=logging.INFO,
-        help="Suppress informative messages and summary statistics.",
-    )
-    group.add_argument(
-        "--verbose",
-        "-v",
-        action="count",
-        help="""
+    group.add_argument('--quiet', '-q', dest='loglevel',
+        action="store_const", const=logging.WARNING, default=logging.INFO,
+        help="Suppress informative messages and summary statistics.")
+    group.add_argument('--verbose', '-v', action="count", help="""
         Print additional information for each processed file.
         Specify twice to further increase verbosity.
-        """,
-    )
+        """)
 
-    parser.add_argument(
-        "--cwd",
-        "-C",
-        metavar="DIRECTORY",
-        help="""
+    parser.add_argument('--cwd', '-C', metavar="DIRECTORY", help="""
         Run as if %(prog)s was started in directory %(metavar)s.
         This affects how --work-tree, --git-dir and PATHSPEC arguments are handled.
         See 'man 1 git' or 'git --help' for more information.
-        """,
-    )
+        """)
 
-    parser.add_argument(
-        "--git-dir",
-        dest="gitdir",
-        metavar="GITDIR",
-        help="""
+    parser.add_argument('--git-dir', dest='gitdir', metavar="GITDIR", help="""
         Path to the git repository, by default auto-discovered by searching
         the current directory and its parents for a .git/ subdirectory.
-        """,
-    )
+        """)
 
-    parser.add_argument(
-        "--work-tree",
-        dest="workdir",
-        metavar="WORKTREE",
-        help="""
+    parser.add_argument('--work-tree', dest='workdir', metavar="WORKTREE", help="""
         Path to the work tree root, by default the parent of GITDIR if it's
         automatically discovered, or the current directory if GITDIR is set.
-        """,
-    )
+        """)
 
-    parser.add_argument(
-        "--force",
-        "-f",
-        default=False,
-        action="store_true",
-        help="""
+    parser.add_argument('--force', '-f', default=False, action="store_true", help="""
         Force updating files with uncommitted modifications.
         Untracked files and uncommitted deletions, renames and additions are
         always ignored.
-        """,
-    )
+        """)
 
-    parser.add_argument(
-        "--merge",
-        "-m",
-        default=False,
-        action="store_true",
-        help="""
+    parser.add_argument('--merge', '-m', default=False, action="store_true", help="""
         Include merge commits.
         Leads to more recent times and more files per commit, thus with the same
         time, which may or may not be what you want.
@@ -175,130 +138,71 @@ def parse_args():
         are found sooner, which can improve performance, sometimes substantially.
         But as merge commits are usually huge, processing them may also take longer.
         By default, merge commits are only used for files missing from regular commits.
-        """,
-    )
+        """)
 
-    parser.add_argument(
-        "--first-parent",
-        default=False,
-        action="store_true",
-        help="""
+    parser.add_argument('--first-parent', default=False, action="store_true", help="""
         Consider only the first parent, the "main branch", when evaluating merge commits.
         Only effective when merge commits are processed, either when --merge is
         used or when finding missing files after the first regular log search.
         See --skip-missing.
-        """,
-    )
+        """)
 
-    parser.add_argument(
-        "--skip-missing",
-        "-s",
-        dest="missing",
-        default=True,
-        action="store_false",
-        help="""
+    parser.add_argument('--skip-missing', '-s', dest="missing", default=True,
+        action="store_false", help="""
         Do not try to find missing files.
         If merge commits were not evaluated with --merge and some files were
         not found in regular commits, by default %(prog)s searches for these
         files again in the merge commits.
         This option disables this retry, so files found only in merge commits
         will not have their timestamp updated.
-        """,
-    )
+        """)
 
-    parser.add_argument(
-        "--no-directories",
-        "-D",
-        dest="dirs",
-        default=True,
-        action="store_false",
-        help="""
+    parser.add_argument('--no-directories', '-D', dest='dirs', default=True,
+        action="store_false", help="""
         Do not update directory timestamps.
         By default, use the time of its most recently created, renamed or deleted file.
         Note that just modifying a file will NOT update its directory time.
-        """,
-    )
+        """)
 
-    parser.add_argument(
-        "--test",
-        "-t",
-        default=False,
-        action="store_true",
-        help="Test run: do not actually update any file timestamp.",
-    )
+    parser.add_argument('--test', '-t', default=False, action="store_true",
+        help="Test run: do not actually update any file timestamp.")
 
-    parser.add_argument(
-        "--commit-time",
-        "-c",
-        dest="commit_time",
-        default=False,
-        action="store_true",
-        help="Use commit time instead of author time.",
-    )
+    parser.add_argument('--commit-time', '-c', dest='commit_time', default=False,
+        action='store_true', help="Use commit time instead of author time.")
 
-    parser.add_argument(
-        "--oldest-time",
-        "-o",
-        dest="reverse_order",
-        default=False,
-        action="store_true",
-        help="""
+    parser.add_argument('--oldest-time', '-o', dest='reverse_order', default=False,
+        action='store_true', help="""
         Update times based on the oldest, instead of the most recent commit of a file.
         This reverses the order in which the git log is processed to emulate a
         file "creation" date. Note this will be inaccurate for files deleted and
         re-created at later dates.
-        """,
-    )
+        """)
 
-    parser.add_argument(
-        "--skip-older-than",
-        metavar="SECONDS",
-        type=int,
-        help="""
+    parser.add_argument('--skip-older-than', metavar='SECONDS', type=int, help="""
         Ignore files that are currently older than %(metavar)s.
         Useful in workflows that assume such files already have a correct timestamp,
         as it may improve performance by processing fewer files.
-        """,
-    )
+        """)
 
-    parser.add_argument(
-        "--skip-older-than-commit",
-        "-N",
-        default=False,
-        action="store_true",
-        help="""
+    parser.add_argument('--skip-older-than-commit', '-N', default=False,
+        action='store_true', help="""
         Ignore files older than the timestamp it would be updated to.
         Such files may be considered "original", likely in the author's repository.
-        """,
-    )
+        """)
 
-    parser.add_argument(
-        "--unique-times",
-        default=False,
-        action="store_true",
-        help="""
+    parser.add_argument('--unique-times', default=False, action="store_true", help="""
         Set the microseconds to a unique value per commit.
         Allows telling apart changes that would otherwise have identical timestamps,
         as git's time accuracy is in seconds.
-        """,
-    )
+        """)
 
-    parser.add_argument(
-        "pathspec",
-        nargs="*",
-        metavar="PATHSPEC",
-        help="""
+    parser.add_argument('pathspec', nargs='*', metavar='PATHSPEC', help="""
         Only modify paths matching %(metavar)s, relative to current directory.
         By default, update all but untracked files and submodules.
-        """,
-    )
+        """)
 
-    parser.add_argument(
-        "--version",
-        "-V",
-        action="version",
-        version="%(prog)s version {version}".format(version=get_version()),
-    )
+    parser.add_argument('--version', '-V', action='version',
+        version='%(prog)s version {version}'.format(version=get_version()))
 
     args_ = parser.parse_args()
     if args_.verbose:
@@ -308,18 +212,17 @@ def parse_args():
 
 
 def get_version(version=__version__):
-    if not version.endswith("+dev"):
+    if not version.endswith('+dev'):
         return version
     try:
         cwd = os.path.dirname(os.path.realpath(__file__))
-        return Git(cwd=cwd, errors=False).describe().lstrip("v")
+        return Git(cwd=cwd, errors=False).describe().lstrip('v')
     except Git.Error:
-        return "-".join((version, "unknown"))
+        return '-'.join((version, "unknown"))
 
 
 # Helper functions ############################################################
 
-
 def setup_logging():
     """Add TRACE logging level and corresponding method, return the root logger"""
     logging.TRACE = TRACE = logging.DEBUG // 2
@@ -352,13 +255,11 @@ def normalize(path):
     if path and path[0] == '"':
         # Python 2: path = path[1:-1].decode("string-escape")
         # Python 3: https://stackoverflow.com/a/46650050/624066
-        path = (
-            path[1:-1]  # Remove enclosing double quotes
-            .encode("latin1")  # Convert to bytes, required by 'unicode-escape'
-            .decode("unicode-escape")  # Perform the actual octal-escaping decode
-            .encode("latin1")  # 1:1 mapping to bytes, UTF-8 encoded
-            .decode("utf8", "surrogateescape")
-        )  # Decode from UTF-8
+        path = (path[1:-1]                 # Remove enclosing double quotes
+                .encode('latin1')          # Convert to bytes, required by 'unicode-escape'
+                .decode('unicode-escape')  # Perform the actual octal-escaping decode
+                .encode('latin1')          # 1:1 mapping to bytes, UTF-8 encoded
+                .decode('utf8', 'surrogateescape'))  # Decode from UTF-8
     if NORMALIZE_PATHS:
         # Make sure the slash matches the OS; for Windows we need a backslash
         path = os.path.normpath(path)
@@ -381,12 +282,12 @@ def touch_ns(path, mtime_ns):
 
 def isodate(secs: int):
     # time.localtime() accepts floats, but discards fractional part
-    return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(secs))
+    return time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(secs))
 
 
 def isodate_ns(ns: int):
     # for integers fromtimestamp() is equivalent and ~16% slower than isodate()
-    return datetime.datetime.fromtimestamp(ns / 1000000000).isoformat(sep=" ")
+    return datetime.datetime.fromtimestamp(ns / 1000000000).isoformat(sep=' ')
 
 
 def get_mtime_ns(secs: int, idx: int):
@@ -404,49 +305,35 @@ def get_mtime_path(path):
 
 # Git class and parse_log(), the heart of the script ##########################
 
-
 class Git:
     def __init__(self, workdir=None, gitdir=None, cwd=None, errors=True):
-        self.gitcmd = ["git"]
+        self.gitcmd = ['git']
         self.errors = errors
         self._proc = None
-        if workdir:
-            self.gitcmd.extend(("--work-tree", workdir))
-        if gitdir:
-            self.gitcmd.extend(("--git-dir", gitdir))
-        if cwd:
-            self.gitcmd.extend(("-C", cwd))
+        if workdir: self.gitcmd.extend(('--work-tree', workdir))
+        if gitdir:  self.gitcmd.extend(('--git-dir',   gitdir))
+        if cwd:     self.gitcmd.extend(('-C',          cwd))
         self.workdir, self.gitdir = self._get_repo_dirs()
 
     def ls_files(self, paths: list = None):
-        return (normalize(_) for _ in self._run("ls-files --full-name", paths))
+        return (normalize(_) for _ in self._run('ls-files --full-name', paths))
 
     def ls_dirty(self, force=False):
-        return (
-            normalize(_[3:].split(" -> ", 1)[-1])
-            for _ in self._run("status --porcelain")
-            if _[:2] != "??" and (not force or (_[0] in ("R", "A") or _[1] == "D"))
-        )
+        return (normalize(_[3:].split(' -> ', 1)[-1])
+                for _ in self._run('status --porcelain')
+                if _[:2] != '??' and (not force or (_[0] in ('R', 'A')
+                                                    or _[1] == 'D')))
 
-    def log(
-        self,
-        merge=False,
-        first_parent=False,
-        commit_time=False,
-        reverse_order=False,
-        paths: list = None,
-    ):
-        cmd = "whatchanged --pretty={}".format("%ct" if commit_time else "%at")
-        if merge:
-            cmd += " -m"
-        if first_parent:
-            cmd += " --first-parent"
-        if reverse_order:
-            cmd += " --reverse"
+    def log(self, merge=False, first_parent=False, commit_time=False,
+            reverse_order=False, paths: list = None):
+        cmd = 'whatchanged --pretty={}'.format('%ct' if commit_time else '%at')
+        if merge:         cmd += ' -m'
+        if first_parent:  cmd += ' --first-parent'
+        if reverse_order: cmd += ' --reverse'
         return self._run(cmd, paths)
 
     def describe(self):
-        return self._run("describe --tags", check=True)[0]
+        return self._run('describe --tags', check=True)[0]
 
     def terminate(self):
         if self._proc is None:
@@ -458,22 +345,18 @@ class Git:
             pass
 
     def _get_repo_dirs(self):
-        return (
-            os.path.normpath(_)
-            for _ in self._run(
-                "rev-parse --show-toplevel --absolute-git-dir", check=True
-            )
-        )
+        return (os.path.normpath(_) for _ in
+            self._run('rev-parse --show-toplevel --absolute-git-dir', check=True))
 
     def _run(self, cmdstr: str, paths: list = None, output=True, check=False):
         cmdlist = self.gitcmd + shlex.split(cmdstr)
         if paths:
-            cmdlist.append("--")
+            cmdlist.append('--')
             cmdlist.extend(paths)
-        popen_args = dict(universal_newlines=True, encoding="utf8")
+        popen_args = dict(universal_newlines=True, encoding='utf8')
         if not self.errors:
-            popen_args["stderr"] = subprocess.DEVNULL
-        log.trace("Executing: %s", " ".join(cmdlist))
+            popen_args['stderr'] = subprocess.DEVNULL
+        log.trace("Executing: %s", ' '.join(cmdlist))
         if not output:
             return subprocess.call(cmdlist, **popen_args)
         if check:
@@ -496,26 +379,30 @@ def parse_log(filelist, dirlist, stats, git, merge=False, filterlist=None):
     mtime = 0
     datestr = isodate(0)
     for line in git.log(
-        merge, args.first_parent, args.commit_time, args.reverse_order, filterlist
+            merge,
+            args.first_parent,
+            args.commit_time,
+            args.reverse_order,
+            filterlist
     ):
-        stats["loglines"] += 1
+        stats['loglines'] += 1
 
         # Blank line between Date and list of files
         if not line:
             continue
 
         # Date line
-        if line[0] != ":":  # Faster than `not line.startswith(':')`
-            stats["commits"] += 1
+        if line[0] != ':':  # Faster than `not line.startswith(':')`
+            stats['commits'] += 1
             mtime = int(line)
             if args.unique_times:
-                mtime = get_mtime_ns(mtime, stats["commits"])
+                mtime = get_mtime_ns(mtime, stats['commits'])
             if args.debug:
                 datestr = isodate(mtime)
             continue
 
         # File line: three tokens if it describes a renaming, otherwise two
-        tokens = line.split("\t")
+        tokens = line.split('\t')
 
         # Possible statuses:
         # M: Modified (content changed)
@@ -524,7 +411,7 @@ def parse_log(filelist, dirlist, stats, git, merge=False, filterlist=None):
         # T: Type changed: to/from regular file, symlinks, submodules
         # R099: Renamed (moved), with % of unchanged content. 100 = pure rename
         # Not possible in log: C=Copied, U=Unmerged, X=Unknown, B=pairing Broken
-        status = tokens[0].split(" ")[-1]
+        status = tokens[0].split(' ')[-1]
         file = tokens[-1]
 
         # Handles non-ASCII chars and OS path separator
@@ -532,76 +419,56 @@ def parse_log(filelist, dirlist, stats, git, merge=False, filterlist=None):
 
         def do_file():
             if args.skip_older_than_commit and get_mtime_path(file) <= mtime:
-                stats["skip"] += 1
+                stats['skip'] += 1
                 return
             if args.debug:
-                log.debug(
-                    "%d\t%d\t%d\t%s\t%s",
-                    stats["loglines"],
-                    stats["commits"],
-                    stats["files"],
-                    datestr,
-                    file,
-                )
+                log.debug("%d\t%d\t%d\t%s\t%s",
+                          stats['loglines'], stats['commits'], stats['files'],
+                          datestr, file)
             try:
                 touch(os.path.join(git.workdir, file), mtime)
-                stats["touches"] += 1
+                stats['touches'] += 1
             except Exception as e:
                 log.error("ERROR: %s: %s", e, file)
-                stats["errors"] += 1
+                stats['errors'] += 1
 
         def do_dir():
             if args.debug:
-                log.debug(
-                    "%d\t%d\t-\t%s\t%s",
-                    stats["loglines"],
-                    stats["commits"],
-                    datestr,
-                    "{}/".format(dirname or "."),
-                )
+                log.debug("%d\t%d\t-\t%s\t%s",
+                          stats['loglines'], stats['commits'],
+                          datestr, "{}/".format(dirname or '.'))
             try:
                 touch(os.path.join(git.workdir, dirname), mtime)
-                stats["dirtouches"] += 1
+                stats['dirtouches'] += 1
             except Exception as e:
                 log.error("ERROR: %s: %s", e, dirname)
-                stats["direrrors"] += 1
+                stats['direrrors'] += 1
 
         if file in filelist:
-            stats["files"] -= 1
+            stats['files'] -= 1
             filelist.remove(file)
             do_file()
 
-        if args.dirs and status in ("A", "D"):
+        if args.dirs and status in ('A', 'D'):
             dirname = os.path.dirname(file)
             if dirname in dirlist:
                 dirlist.remove(dirname)
                 do_dir()
 
         # All files done?
-        if not stats["files"]:
+        if not stats['files']:
             git.terminate()
             return
 
 
 # Main Logic ##################################################################
 
-
 def main():
     start = time.time()  # yes, Wall time. CPU time is not realistic for users.
-    stats = {
-        _: 0
-        for _ in (
-            "loglines",
-            "commits",
-            "touches",
-            "skip",
-            "errors",
-            "dirtouches",
-            "direrrors",
-        )
-    }
+    stats = {_: 0 for _ in ('loglines', 'commits', 'touches', 'skip', 'errors',
+                            'dirtouches', 'direrrors')}
 
-    logging.basicConfig(level=args.loglevel, format="%(message)s")
+    logging.basicConfig(level=args.loglevel, format='%(message)s')
     log.trace("Arguments: %s", args)
 
     # First things first: Where and Who are we?
@@ -632,16 +499,13 @@ def main():
 
             # Symlink (to file, to dir or broken - git handles the same way)
             if not UPDATE_SYMLINKS and os.path.islink(fullpath):
-                log.warning(
-                    "WARNING: Skipping symlink, no OS support for updates: %s", path
-                )
+                log.warning("WARNING: Skipping symlink, no OS support for updates: %s",
+                            path)
                 continue
 
             # skip files which are older than given threshold
-            if (
-                args.skip_older_than
-                and start - get_mtime_path(fullpath) > args.skip_older_than
-            ):
+            if (args.skip_older_than
+                    and start - get_mtime_path(fullpath) > args.skip_older_than):
                 continue
 
             # Always add files relative to worktree root
@@ -655,17 +519,15 @@ def main():
     else:
         dirty = set(git.ls_dirty())
         if dirty:
-            log.warning(
-                "WARNING: Modified files in the working directory were ignored."
-                "\nTo include such files, commit your changes or use --force."
-            )
+            log.warning("WARNING: Modified files in the working directory were ignored."
+                "\nTo include such files, commit your changes or use --force.")
             filelist -= dirty
 
     # Build dir list to be processed
     dirlist = set(os.path.dirname(_) for _ in filelist) if args.dirs else set()
 
-    stats["totalfiles"] = stats["files"] = len(filelist)
-    log.info("{0:,} files to be processed in work dir".format(stats["totalfiles"]))
+    stats['totalfiles'] = stats['files'] = len(filelist)
+    log.info("{0:,} files to be processed in work dir".format(stats['totalfiles']))
 
     if not filelist:
         # Nothing to do. Exit silently and without errors, just like git does
@@ -682,18 +544,10 @@ def main():
         if args.missing and not args.merge:
             filterlist = list(filelist)
             missing = len(filterlist)
-            log.info(
-                "{0:,} files not found in log, trying merge commits".format(missing)
-            )
+            log.info("{0:,} files not found in log, trying merge commits".format(missing))
             for i in range(0, missing, STEPMISSING):
-                parse_log(
-                    filelist,
-                    dirlist,
-                    stats,
-                    git,
-                    merge=True,
-                    filterlist=filterlist[i : i + STEPMISSING],
-                )
+                parse_log(filelist, dirlist, stats, git,
+                          merge=True, filterlist=filterlist[i:i + STEPMISSING])
 
         # Still missing some?
         for file in filelist:
@@ -702,33 +556,29 @@ def main():
     # Final statistics
     # Suggestion: use git-log --before=mtime to brag about skipped log entries
     def log_info(msg, *a, width=13):
-        ifmt = "{:%d,}" % (width,)  # not using 'n' for consistency with ffmt
-        ffmt = "{:%d,.2f}" % (width,)
+        ifmt = '{:%d,}'    % (width,)  # not using 'n' for consistency with ffmt
+        ffmt = '{:%d,.2f}' % (width,)
         # %-formatting lacks a thousand separator, must pre-render with .format()
-        log.info(msg.replace("%d", ifmt).replace("%f", ffmt).format(*a))
+        log.info(msg.replace('%d', ifmt).replace('%f', ffmt).format(*a))
 
     log_info(
-        "Statistics:\n%f seconds\n%d log lines processed\n%d commits evaluated",
-        time.time() - start,
-        stats["loglines"],
-        stats["commits"],
-    )
+        "Statistics:\n"
+        "%f seconds\n"
+        "%d log lines processed\n"
+        "%d commits evaluated",
+        time.time() - start, stats['loglines'], stats['commits'])
 
     if args.dirs:
-        if stats["direrrors"]:
-            log_info("%d directory update errors", stats["direrrors"])
-        log_info("%d directories updated", stats["dirtouches"])
+        if stats['direrrors']: log_info("%d directory update errors", stats['direrrors'])
+        log_info("%d directories updated", stats['dirtouches'])
 
-    if stats["touches"] != stats["totalfiles"]:
-        log_info("%d files", stats["totalfiles"])
-    if stats["skip"]:
-        log_info("%d files skipped", stats["skip"])
-    if stats["files"]:
-        log_info("%d files missing", stats["files"])
-    if stats["errors"]:
-        log_info("%d file update errors", stats["errors"])
+    if stats['touches'] != stats['totalfiles']:
+                        log_info("%d files",              stats['totalfiles'])
+    if stats['skip']:   log_info("%d files skipped",      stats['skip'])
+    if stats['files']:  log_info("%d files missing",      stats['files'])
+    if stats['errors']: log_info("%d file update errors", stats['errors'])
 
-    log_info("%d files updated", stats["touches"])
+    log_info("%d files updated", stats['touches'])
 
     if args.test:
         log.info("TEST RUN - No files modified!")

.github/workflows/.codespell-exclude

@@ -0,0 +1,6 @@
+"NotIn": "not in",
+- `/checkin`: Check-in
+docs/docs/integrations/providers/trulens.mdx
+self.assertIn(
+from trulens_eval import Tru
+tru = Tru()

.github/workflows/_compile_integration_test.yml

@@ -1,4 +1,4 @@
-name: '🔗 Compile Integration Tests'
+name: compile-integration-test
 
 on:
   workflow_call:
@@ -25,24 +25,24 @@ jobs:
         working-directory: ${{ inputs.working-directory }}
     runs-on: ubuntu-latest
     timeout-minutes: 20
-    name: 'Python ${{ inputs.python-version }}'
+    name: "uv run pytest -m compile tests/integration_tests #${{ inputs.python-version }}"
     steps:
       - uses: actions/checkout@v4
 
-      - name: '🐍 Set up Python ${{ inputs.python-version }} + UV'
+      - name: Set up Python ${{ inputs.python-version }} + uv
         uses: "./.github/actions/uv_setup"
         with:
           python-version: ${{ inputs.python-version }}
 
-      - name: '📦 Install Integration Dependencies'
+      - name: Install integration dependencies
         shell: bash
         run: uv sync --group test --group test_integration
 
-      - name: '🔗 Check Integration Tests Compile'
+      - name: Check integration tests compile
         shell: bash
         run: uv run pytest -m compile tests/integration_tests
 
-      - name: '🧹 Verify Clean Working Directory'
+      - name: Ensure the tests did not create any additional files
         shell: bash
         run: |
           set -eu

.github/workflows/_integration_test.yml

@@ -1,5 +1,4 @@
-name: '🚀 Integration Tests'
-run-name: 'Test ${{ inputs.working-directory }} on Python ${{ inputs.python-version }}'
+name: Integration Tests
 
 on:
   workflow_dispatch:
@@ -12,7 +11,6 @@ on:
         required: true
         type: string
         description: "Python version to use"
-        default: "3.11"
 
 permissions:
   contents: read
@@ -26,20 +24,20 @@ jobs:
       run:
         working-directory: ${{ inputs.working-directory }}
     runs-on: ubuntu-latest
-    name: 'Python ${{ inputs.python-version }}'
+    name: Python ${{ inputs.python-version }}
     steps:
       - uses: actions/checkout@v4
 
-      - name: '🐍 Set up Python ${{ inputs.python-version }} + UV'
+      - name: Set up Python ${{ inputs.python-version }} + uv
         uses: "./.github/actions/uv_setup"
         with:
           python-version: ${{ inputs.python-version }}
 
-      - name: '📦 Install Integration Dependencies'
+      - name: Install dependencies
         shell: bash
         run: uv sync --group test --group test_integration
 
-      - name: '🚀 Run Integration Tests'
+      - name: Run integration tests
         shell: bash
         env:
           AI21_API_KEY: ${{ secrets.AI21_API_KEY }}

.github/workflows/_lint.yml

@@ -1,6 +1,4 @@
-name: '🧹 Code Linting'
-# Runs code quality checks using ruff, mypy, and other linting tools
-# Checks both package code and test code for consistency
+name: lint
 
 on:
   workflow_call:
@@ -26,21 +24,19 @@ env:
   UV_FROZEN: "true"
 
 jobs:
-  # Linting job - runs quality checks on package and test code
   build:
-    name: 'Python ${{ inputs.python-version }}'
+    name: "make lint #${{ inputs.python-version }}"
     runs-on: ubuntu-latest
     timeout-minutes: 20
     steps:
-      - name: '📋 Checkout Code'
-        uses: actions/checkout@v4
+      - uses: actions/checkout@v4
 
-      - name: '🐍 Set up Python ${{ inputs.python-version }} + UV'
+      - name: Set up Python ${{ inputs.python-version }} + uv
         uses: "./.github/actions/uv_setup"
         with:
           python-version: ${{ inputs.python-version }}
 
-      - name: '📦 Install Lint & Typing Dependencies'
+      - name: Install dependencies
         # Also installs dev/lint/test/typing dependencies, to ensure we have
         # type hints for as many of our libraries as possible.
         # This helps catch errors that require dependencies to be spotted, for example:
@@ -53,12 +49,12 @@ jobs:
         run: |
           uv sync --group lint --group typing
 
-      - name: '🔍 Analyze Package Code with Linters'
+      - name: Analysing the code with our lint
         working-directory: ${{ inputs.working-directory }}
         run: |
           make lint_package
 
-      - name: '📦 Install Unit Test Dependencies'
+      - name: Install unit test dependencies
         # Also installs dev/lint/test/typing dependencies, to ensure we have
         # type hints for as many of our libraries as possible.
         # This helps catch errors that require dependencies to be spotted, for example:
@@ -71,13 +67,13 @@ jobs:
         working-directory: ${{ inputs.working-directory }}
         run: |
           uv sync --inexact --group test
-      - name: '📦 Install Unit + Integration Test Dependencies'
+      - name: Install unit+integration test dependencies
         if: ${{ startsWith(inputs.working-directory, 'libs/partners/') }}
         working-directory: ${{ inputs.working-directory }}
         run: |
           uv sync --inexact --group test --group test_integration
 
-      - name: '🔍 Analyze Test Code with Linters'
+      - name: Analysing the code with our lint
         working-directory: ${{ inputs.working-directory }}
         run: |
           make lint_tests

.github/workflows/_release.yml

@@ -1,5 +1,5 @@
-name: '🚀 Package Release'
-run-name: 'Release ${{ inputs.working-directory }} ${{ inputs.release-version }}'
+name: Release
+run-name: Release ${{ inputs.working-directory }} by @${{ github.actor }}
 on:
   workflow_call:
     inputs:
@@ -14,16 +14,11 @@ on:
         type: string
         description: "From which folder this pipeline executes"
         default: 'libs/langchain'
-      release-version:
-        required: true
-        type: string
-        default: '0.1.0'
-        description: "New version of package being released"
       dangerous-nonmaster-release:
         required: false
         type: boolean
         default: false
-        description: "Release from a non-master branch (danger!) - Only use for hotfixes"
+        description: "Release from a non-master branch (danger!)"
 
 env:
   PYTHON_VERSION: "3.11"
@@ -31,8 +26,6 @@ env:
   UV_NO_SYNC: "true"
 
 jobs:
-  # Build the distribution package and extract version info
-  # Runs in isolated environment with minimal permissions for security
   build:
     if: github.ref == 'refs/heads/master' || inputs.dangerous-nonmaster-release
     environment: Scheduled testing
@@ -116,7 +109,7 @@ jobs:
             # Look for the latest release of the same base version
             REGEX="^$PKG_NAME==$BASE_VERSION\$"
             PREV_TAG=$(git tag --sort=-creatordate | (grep -P "$REGEX" || true) | head -1)
-
+            
             # If no exact base version match, look for the latest release of any kind
             if [ -z "$PREV_TAG" ]; then
               REGEX="^$PKG_NAME==\\d+\\.\\d+\\.\\d+\$"
@@ -127,7 +120,7 @@ jobs:
             PREV_TAG="$PKG_NAME==${VERSION%.*}.$(( ${VERSION##*.} - 1 ))"; [[ "${VERSION##*.}" -eq 0 ]] && PREV_TAG=""
 
             # backup case if releasing e.g. 0.3.0, looks up last release
-            # note if last release (chronologically) was e.g. 0.1.47 it will get
+            # note if last release (chronologically) was e.g. 0.1.47 it will get 
             # that instead of the last 0.2 release
             if [ -z "$PREV_TAG" ]; then
               REGEX="^$PKG_NAME==\\d+\\.\\d+\\.\\d+\$"
@@ -220,7 +213,7 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
 
-      - uses: actions/download-artifact@v5
+      - uses: actions/download-artifact@v4
         with:
           name: dist
           path: ${{ inputs.working-directory }}/dist/
@@ -347,7 +340,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        partner: [openai, anthropic]
+        partner: [openai]
       fail-fast: false  # Continue testing other partners if one fails
     env:
       ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
@@ -379,7 +372,7 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
 
-      - uses: actions/download-artifact@v5
+      - uses: actions/download-artifact@v4
         if: startsWith(inputs.working-directory, 'libs/core')
         with:
           name: dist
@@ -388,12 +381,11 @@ jobs:
       - name: Test against ${{ matrix.partner }}
         if: startsWith(inputs.working-directory, 'libs/core')
         run: |
-          # Identify latest tag, excluding pre-releases
+          # Identify latest tag
           LATEST_PACKAGE_TAG="$(
             git ls-remote --tags origin "langchain-${{ matrix.partner }}*" \
             | awk '{print $2}' \
             | sed 's|refs/tags/||' \
-            | grep -Ev '==[^=]*(\.?dev[0-9]*|\.?rc[0-9]*)$' \
             | sort -Vr \
             | head -n 1
           )"
@@ -447,7 +439,7 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
 
-      - uses: actions/download-artifact@v5
+      - uses: actions/download-artifact@v4
         with:
           name: dist
           path: ${{ inputs.working-directory }}/dist/
@@ -486,11 +478,11 @@ jobs:
         with:
           python-version: ${{ env.PYTHON_VERSION }}
 
-      - uses: actions/download-artifact@v5
+      - uses: actions/download-artifact@v4
         with:
           name: dist
           path: ${{ inputs.working-directory }}/dist/
-
+          
       - name: Create Tag
         uses: ncipollo/release-action@v1
         with:

.github/workflows/_test.yml

@@ -1,6 +1,4 @@
-name: '🧪 Unit Testing'
-# Runs unit tests with both current and minimum supported dependency versions
-# to ensure compatibility across the supported range
+name: test
 
 on:
   workflow_call:
@@ -22,33 +20,31 @@ env:
   UV_NO_SYNC: "true"
 
 jobs:
-  # Main test job - runs unit tests with current deps, then retests with minimum versions
   build:
     defaults:
       run:
         working-directory: ${{ inputs.working-directory }}
     runs-on: ubuntu-latest
     timeout-minutes: 20
-    name: 'Python ${{ inputs.python-version }}'
+    name: "make test #${{ inputs.python-version }}"
     steps:
-      - name: '📋 Checkout Code'
-        uses: actions/checkout@v4
+      - uses: actions/checkout@v4
 
-      - name: '🐍 Set up Python ${{ inputs.python-version }} + UV'
+      - name: Set up Python ${{ inputs.python-version }} + uv
         uses: "./.github/actions/uv_setup"
         id: setup-python
         with:
           python-version: ${{ inputs.python-version }}
-      - name: '📦 Install Test Dependencies'
+      - name: Install dependencies
         shell: bash
         run: uv sync --group test --dev
 
-      - name: '🧪 Run Core Unit Tests'
+      - name: Run core tests
         shell: bash
         run: |
           make test
 
-      - name: '🔍 Calculate Minimum Dependency Versions'
+      - name: Get minimum versions
         working-directory: ${{ inputs.working-directory }}
         id: min-version
         shell: bash
@@ -59,7 +55,7 @@ jobs:
           echo "min-versions=$min_versions" >> "$GITHUB_OUTPUT"
           echo "min-versions=$min_versions"
 
-      - name: '🧪 Run Tests with Minimum Dependencies'
+      - name: Run unit tests with minimum dependency versions
         if: ${{ steps.min-version.outputs.min-versions != '' }}
         env:
           MIN_VERSIONS: ${{ steps.min-version.outputs.min-versions }}
@@ -68,7 +64,7 @@ jobs:
           make tests
         working-directory: ${{ inputs.working-directory }}
 
-      - name: '🧹 Verify Clean Working Directory'
+      - name: Ensure the tests did not create any additional files
         shell: bash
         run: |
           set -eu
@@ -79,4 +75,4 @@ jobs:
           # grep will exit non-zero if the target message isn't found,
           # and `set -e` above will cause the step to fail.
           echo "$STATUS" | grep 'nothing to commit, working tree clean'
-
+          

.github/workflows/_test_doc_imports.yml

@@ -1,4 +1,4 @@
-name: '📑 Documentation Import Testing'
+name: test_doc_imports
 
 on:
   workflow_call:
@@ -18,30 +18,29 @@ jobs:
   build:
     runs-on: ubuntu-latest
     timeout-minutes: 20
-    name: '🔍 Check Doc Imports (Python ${{ inputs.python-version }})'
+    name: "check doc imports #${{ inputs.python-version }}"
     steps:
-      - name: '📋 Checkout Code'
-        uses: actions/checkout@v4
+      - uses: actions/checkout@v4
 
-      - name: '🐍 Set up Python ${{ inputs.python-version }} + UV'
+      - name: Set up Python ${{ inputs.python-version }} + uv
         uses: "./.github/actions/uv_setup"
         with:
           python-version: ${{ inputs.python-version }}
 
-      - name: '📦 Install Test Dependencies'
+      - name: Install dependencies
         shell: bash
         run: uv sync --group test
 
-      - name: '📦 Install LangChain in Editable Mode'
+      - name: Install langchain editable
         run: |
           VIRTUAL_ENV=.venv uv pip install langchain-experimental langchain-community -e libs/core libs/langchain
 
-      - name: '🔍 Validate Documentation Import Statements'
+      - name: Check doc imports
         shell: bash
         run: |
           uv run python docs/scripts/check_imports.py
 
-      - name: '🧹 Verify Clean Working Directory'
+      - name: Ensure the test did not create any additional files
         shell: bash
         run: |
           set -eu

.github/workflows/_test_pydantic.yml

@@ -1,4 +1,4 @@
-name: '🐍 Pydantic Version Testing'
+name: test pydantic intermediate versions
 
 on:
   workflow_call:
@@ -31,30 +31,29 @@ jobs:
         working-directory: ${{ inputs.working-directory }}
     runs-on: ubuntu-latest
     timeout-minutes: 20
-    name: 'Pydantic ~=${{ inputs.pydantic-version }}'
+    name: "make test # pydantic: ~=${{ inputs.pydantic-version }}, python: ${{ inputs.python-version }}, "
     steps:
-      - name: '📋 Checkout Code'
-        uses: actions/checkout@v4
+      - uses: actions/checkout@v4
 
-      - name: '🐍 Set up Python ${{ inputs.python-version }} + UV'
+      - name: Set up Python ${{ inputs.python-version }} + uv
         uses: "./.github/actions/uv_setup"
         with:
           python-version: ${{ inputs.python-version }}
 
-      - name: '📦 Install Test Dependencies'
+      - name: Install dependencies
         shell: bash
         run: uv sync --group test
 
-      - name: '🔄 Install Specific Pydantic Version'
+      - name: Overwrite pydantic version
         shell: bash
         run: VIRTUAL_ENV=.venv uv pip install pydantic~=${{ inputs.pydantic-version }}
 
-      - name: '🧪 Run Core Tests'
+      - name: Run core tests
         shell: bash
         run: |
           make test
 
-      - name: '🧹 Verify Clean Working Directory'
+      - name: Ensure the tests did not create any additional files
         shell: bash
         run: |
           set -eu
@@ -64,4 +63,4 @@ jobs:
 
           # grep will exit non-zero if the target message isn't found,
           # and `set -e` above will cause the step to fail.
-          echo "$STATUS" | grep 'nothing to commit, working tree clean'
+          echo "$STATUS" | grep 'nothing to commit, working tree clean'

.github/workflows/_test_release.yml

@@ -1,4 +1,4 @@
-name: '🧪 Test Release Package'
+name: test-release
 
 on:
   workflow_call:
@@ -29,7 +29,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - name: '🐍 Set up Python + UV'
+      - name: Set up Python + uv
         uses: "./.github/actions/uv_setup"
         with:
           python-version: ${{ env.PYTHON_VERSION }}
@@ -45,17 +45,17 @@ jobs:
       # > It is strongly advised to separate jobs for building [...]
       # > from the publish job.
       # https://github.com/pypa/gh-action-pypi-publish#non-goals
-      - name: '📦 Build Project for Distribution'
+      - name: Build project for distribution
         run: uv build
         working-directory: ${{ inputs.working-directory }}
 
-      - name: '⬆️ Upload Build Artifacts'
+      - name: Upload build
         uses: actions/upload-artifact@v4
         with:
           name: test-dist
           path: ${{ inputs.working-directory }}/dist/
 
-      - name: '🔍 Extract Version Information'
+      - name: Check Version
         id: check-version
         shell: python
         working-directory: ${{ inputs.working-directory }}
@@ -85,7 +85,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - uses: actions/download-artifact@v5
+      - uses: actions/download-artifact@v4
         with:
           name: test-dist
           path: ${{ inputs.working-directory }}/dist/

.github/workflows/api_doc_build.yml

@@ -1,21 +1,17 @@
-name: '📚 API Docs'
-run-name: 'Build & Deploy API Reference'
-# Runs daily or can be triggered manually for immediate updates
+name: API Docs Build
 
 on:
   workflow_dispatch:
   schedule:
-    - cron:  '0 13 * * *'  # Daily at 1PM UTC
+    - cron:  '0 13 * * *'
 env:
   PYTHON_VERSION: "3.11"
 
 jobs:
-  # Only runs on main repository to prevent unnecessary builds on forks
   build:
     if: github.repository == 'langchain-ai/langchain' || github.event_name != 'schedule'
     runs-on: ubuntu-latest
-    permissions:
-      contents: read
+    permissions: write-all
     steps:
       - uses: actions/checkout@v4
         with:
@@ -26,7 +22,7 @@ jobs:
           path: langchain-api-docs-html
           token: ${{ secrets.TOKEN_GITHUB_API_DOCS_HTML }}
 
-      - name: '📋 Extract Repository List with yq'
+      - name: Get repos with yq
         id: get-unsorted-repos
         uses: mikefarah/yq@master
         with:
@@ -45,65 +41,56 @@ jobs:
               | .repo
             ' langchain/libs/packages.yml
 
-      - name: '📋 Parse YAML & Checkout Repositories'
+      - name: Parse YAML and checkout repos
         env:
           REPOS_UNSORTED: ${{ steps.get-unsorted-repos.outputs.result }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
           # Get unique repositories
           REPOS=$(echo "$REPOS_UNSORTED" | sort -u)
-          # Checkout each unique repository
+          
+          # Checkout each unique repository that is in langchain-ai org
           for repo in $REPOS; do
-            # Validate repository format (allow any org with proper format)
-            if [[ ! "$repo" =~ ^[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+$ ]]; then
-              echo "Error: Invalid repository format: $repo"
-              exit 1
-            fi
-
             REPO_NAME=$(echo $repo | cut -d'/' -f2)
-
-            # Additional validation for repo name
-            if [[ ! "$REPO_NAME" =~ ^[a-zA-Z0-9_.-]+$ ]]; then
-              echo "Error: Invalid repository name: $REPO_NAME"
-              exit 1
-            fi
             echo "Checking out $repo to $REPO_NAME"
             git clone --depth 1 https://github.com/$repo.git $REPO_NAME
           done
 
-      - name: '🐍 Setup Python ${{ env.PYTHON_VERSION }}'
+      - name: Setup Python ${{ env.PYTHON_VERSION }}
         uses: actions/setup-python@v5
         id: setup-python
         with:
           python-version: ${{ env.PYTHON_VERSION }}
 
-      - name: '📦 Install Initial Python Dependencies'
+      - name: Install initial py deps
         working-directory: langchain
         run: |
           python -m pip install -U uv
           python -m uv pip install --upgrade --no-cache-dir pip setuptools pyyaml
 
-      - name: '📦 Organize Library Directories'
+      - name: Move libs
         run: python langchain/.github/scripts/prep_api_docs_build.py
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: '🧹 Remove Old HTML Files'
+      - name: Rm old html
         run:
           rm -rf langchain-api-docs-html/api_reference_build/html
 
-      - name: '📦 Install Documentation Dependencies'
+      - name: Install dependencies
         working-directory: langchain
         run: |
           python -m uv pip install $(ls ./libs/partners | xargs -I {} echo "./libs/partners/{}") --overrides ./docs/vercel_overrides.txt
           python -m uv pip install libs/core libs/langchain libs/text-splitters libs/community libs/experimental libs/standard-tests
           python -m uv pip install -r docs/api_reference/requirements.txt
 
-      - name: '🔧 Configure Git Settings'
+      - name: Set Git config
         working-directory: langchain
         run: |
           git config --local user.email "actions@github.com"
           git config --local user.name "Github Actions"
 
-      - name: '📚 Build API Documentation'
+      - name: Build docs
         working-directory: langchain
         run: |
           python docs/api_reference/create_api_rst.py

.github/workflows/check-broken-links.yml

@@ -1,4 +1,4 @@
-name: '🔗 Check Broken Links'
+name: Check Broken Links
 
 on:
   workflow_dispatch:
@@ -14,15 +14,15 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - name: '🟢 Setup Node.js 18.x'
+      - name: Use Node.js 18.x
         uses: actions/setup-node@v4
         with:
           node-version: 18.x
           cache: "yarn"
           cache-dependency-path: ./docs/yarn.lock
-      - name: '📦 Install Node Dependencies'
+      - name: Install dependencies
         run: yarn install --immutable --mode=skip-build
         working-directory: ./docs
-      - name: '🔍 Scan Documentation for Broken Links'
+      - name: Check broken links
         run: yarn check-broken-links
         working-directory: ./docs

.github/workflows/check_core_versions.yml

@@ -1,6 +1,4 @@
-name: '🔍 Check `core` Version Equality'
-# Ensures version numbers in pyproject.toml and version.py stay in sync
-# Prevents releases with mismatched version numbers
+name: Check `core` Version Equality
 
 on:
   pull_request:
@@ -18,32 +16,17 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - name: '✅ Verify pyproject.toml & version.py Match'
+      - name: Check version equality
         run: |
-          # Check core versions
-          CORE_PYPROJECT_VERSION=$(grep -Po '(?<=^version = ")[^"]*' libs/core/pyproject.toml)
-          CORE_VERSION_PY_VERSION=$(grep -Po '(?<=^VERSION = ")[^"]*' libs/core/langchain_core/version.py)
+          PYPROJECT_VERSION=$(grep -Po '(?<=^version = ")[^"]*' libs/core/pyproject.toml)
+          VERSION_PY_VERSION=$(grep -Po '(?<=^VERSION = ")[^"]*' libs/core/langchain_core/version.py)
 
-          # Compare core versions
-          if [ "$CORE_PYPROJECT_VERSION" != "$CORE_VERSION_PY_VERSION" ]; then
+          # Compare the two versions
+          if [ "$PYPROJECT_VERSION" != "$VERSION_PY_VERSION" ]; then
             echo "langchain-core versions in pyproject.toml and version.py do not match!"
-            echo "pyproject.toml version: $CORE_PYPROJECT_VERSION"
-            echo "version.py version: $CORE_VERSION_PY_VERSION"
+            echo "pyproject.toml version: $PYPROJECT_VERSION"
+            echo "version.py version: $VERSION_PY_VERSION"
             exit 1
           else
-            echo "Core versions match: $CORE_PYPROJECT_VERSION"
-          fi
-
-          # Check langchain_v1 versions
-          LANGCHAIN_PYPROJECT_VERSION=$(grep -Po '(?<=^version = ")[^"]*' libs/langchain_v1/pyproject.toml)
-          LANGCHAIN_INIT_PY_VERSION=$(grep -Po '(?<=^__version__ = ")[^"]*' libs/langchain_v1/langchain/__init__.py)
-
-          # Compare langchain_v1 versions
-          if [ "$LANGCHAIN_PYPROJECT_VERSION" != "$LANGCHAIN_INIT_PY_VERSION" ]; then
-            echo "langchain_v1 versions in pyproject.toml and __init__.py do not match!"
-            echo "pyproject.toml version: $LANGCHAIN_PYPROJECT_VERSION"
-            echo "version.py version: $LANGCHAIN_INIT_PY_VERSION"
-            exit 1
-          else
-            echo "Langchain v1 versions match: $LANGCHAIN_PYPROJECT_VERSION"
+            echo "Versions match: $PYPROJECT_VERSION"
           fi

.github/workflows/check_diffs.yml

@@ -1,4 +1,4 @@
-name: '🔧 CI'
+name: CI
 
 on:
   push:
@@ -6,7 +6,6 @@ on:
   pull_request:
   merge_group:
 
-# Optimizes CI performance by canceling redundant workflow runs
 # If another push to the same PR or branch happens while this workflow is still running,
 # cancel the earlier run in favor of the next run.
 #
@@ -25,24 +24,16 @@ env:
   UV_NO_SYNC: "true"
 
 jobs:
-  # This job analyzes which files changed and creates a dynamic test matrix
-  # to only run tests/lints for the affected packages, improving CI efficiency
   build:
-    name: 'Detect Changes & Set Matrix'
     runs-on: ubuntu-latest
-    if: ${{ !contains(github.event.pull_request.labels.*.name, 'ci-ignore') }}
     steps:
-      - name: '📋 Checkout Code'
-        uses: actions/checkout@v4
-      - name: '🐍 Setup Python 3.11'
-        uses: actions/setup-python@v5
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
         with:
           python-version: '3.11'
-      - name: '📂 Get Changed Files'
-        id: files
+      - id: files
         uses: Ana06/get-changed-files@v2.3.0
-      - name: '🔍 Analyze Changed Files & Generate Build Matrix'
-        id: set-matrix
+      - id: set-matrix
         run: |
           python -m pip install packaging requests
           python .github/scripts/check_diff.py ${{ steps.files.outputs.all }} >> $GITHUB_OUTPUT
@@ -54,8 +45,8 @@ jobs:
       dependencies: ${{ steps.set-matrix.outputs.dependencies }}
       test-doc-imports: ${{ steps.set-matrix.outputs.test-doc-imports }}
       test-pydantic: ${{ steps.set-matrix.outputs.test-pydantic }}
-  # Run linting only on packages that have changed files
   lint:
+    name: cd ${{ matrix.job-configs.working-directory }}
     needs: [ build ]
     if: ${{ needs.build.outputs.lint != '[]' }}
     strategy:
@@ -68,8 +59,8 @@ jobs:
       python-version: ${{ matrix.job-configs.python-version }}
     secrets: inherit
 
-  # Run unit tests only on packages that have changed files
   test:
+    name: cd ${{ matrix.job-configs.working-directory }}
     needs: [ build ]
     if: ${{ needs.build.outputs.test != '[]' }}
     strategy:
@@ -82,8 +73,8 @@ jobs:
       python-version: ${{ matrix.job-configs.python-version }}
     secrets: inherit
 
-  # Test compatibility with different Pydantic versions for affected packages
   test-pydantic:
+    name: cd ${{ matrix.job-configs.working-directory }}
     needs: [ build ]
     if: ${{ needs.build.outputs.test-pydantic != '[]' }}
     strategy:
@@ -104,12 +95,12 @@ jobs:
         job-configs: ${{ fromJson(needs.build.outputs.test-doc-imports) }}
       fail-fast: false
     uses: ./.github/workflows/_test_doc_imports.yml
+    secrets: inherit
     with:
       python-version: ${{ matrix.job-configs.python-version }}
-    secrets: inherit
 
-  # Verify integration tests compile without actually running them (faster feedback)
   compile-integration-tests:
+    name: cd ${{ matrix.job-configs.working-directory }}
     needs: [ build ]
     if: ${{ needs.build.outputs.compile-integration-tests != '[]' }}
     strategy:
@@ -122,9 +113,8 @@ jobs:
       python-version: ${{ matrix.job-configs.python-version }}
     secrets: inherit
 
-  # Run extended test suites that require additional dependencies
   extended-tests:
-    name: 'Extended Tests'
+    name: "cd ${{ matrix.job-configs.working-directory }} / make extended_tests #${{ matrix.job-configs.python-version }}"
     needs: [ build ]
     if: ${{ needs.build.outputs.extended-tests != '[]' }}
     strategy:
@@ -140,12 +130,12 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - name: '🐍 Set up Python ${{ matrix.job-configs.python-version }} + UV'
+      - name: Set up Python ${{ matrix.job-configs.python-version }} + uv
         uses: "./.github/actions/uv_setup"
         with:
           python-version: ${{ matrix.job-configs.python-version }}
 
-      - name: '📦 Install Dependencies & Run Extended Tests'
+      - name: Install dependencies and run extended tests
         shell: bash
         run: |
           echo "Running extended tests, installing dependencies with uv..."
@@ -154,7 +144,7 @@ jobs:
           VIRTUAL_ENV=.venv uv pip install -r extended_testing_deps.txt
           VIRTUAL_ENV=.venv make extended_tests
 
-      - name: '🧹 Verify Clean Working Directory'
+      - name: Ensure the tests did not create any additional files
         shell: bash
         run: |
           set -eu
@@ -166,9 +156,8 @@ jobs:
           # and `set -e` above will cause the step to fail.
           echo "$STATUS" | grep 'nothing to commit, working tree clean'
 
-  # Final status check - ensures all required jobs passed before allowing merge
   ci_success:
-    name: '✅ CI Success'
+    name: "CI Success"
     needs: [build, lint, test, compile-integration-tests, extended-tests, test-doc-imports, test-pydantic]
     if: |
       always()
@@ -178,7 +167,7 @@ jobs:
       RESULTS_JSON: ${{ toJSON(needs.*.result) }}
       EXIT_CODE: ${{!contains(needs.*.result, 'failure') && !contains(needs.*.result, 'cancelled') && '0' || '1'}}
     steps:
-      - name: '🎉 All Checks Passed'
+      - name: "CI Success"
         run: |
           echo $JOBS_JSON
           echo $RESULTS_JSON

.github/workflows/check_new_docs.yml

@@ -1,4 +1,4 @@
-name: '📑 Integration Docs Lint'
+name: Integration Docs Lint
 
 on:
   push:
@@ -33,6 +33,6 @@ jobs:
             *.ipynb
             *.md
             *.mdx
-      - name: '🔍 Check New Documentation Templates'
+      - name: Check new docs
         run: |
           python docs/scripts/check_templates.py ${{ steps.files.outputs.added }}

.github/workflows/codespell.yml

@@ -0,0 +1,35 @@
+name: CI / cd . / make spell_check
+
+on:
+  push:
+    branches: [master, v0.1, v0.2]
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  codespell:
+    name: (Check for spelling errors)
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install Dependencies
+        run: |
+          pip install toml
+
+      - name: Extract Ignore Words List
+        run: |
+          # Use a Python script to extract the ignore words list from pyproject.toml
+          python .github/workflows/extract_ignored_words_list.py
+        id: extract_ignore_words
+
+#      - name: Codespell
+#        uses: codespell-project/actions-codespell@v2
+#        with:
+#          skip: guide_imports.json,*.ambr,./cookbook/data/imdb_top_1000.csv,*.lock
+#          ignore_words_list: ${{ steps.extract_ignore_words.outputs.ignore_words_list }}
+#          exclude_file: ./.github/workflows/codespell-exclude

.github/workflows/codspeed.yml

@@ -1,4 +1,4 @@
-name: '⚡ CodSpeed'
+name: CodSpeed
 
 on:
   push:
@@ -18,9 +18,8 @@ env:
 
 jobs:
   codspeed:
-    name: 'Benchmark'
+    name: Run benchmarks
     runs-on: ubuntu-latest
-    if: ${{ !contains(github.event.pull_request.labels.*.name, 'codspeed-ignore') }}
     strategy:
       matrix:
         include:
@@ -39,7 +38,7 @@ jobs:
       - uses: actions/checkout@v4
 
       # We have to use 3.12 as 3.13 is not yet supported
-      - name: '📦 Install UV Package Manager'
+      - name: Install uv
         uses: astral-sh/setup-uv@v6
         with:
           python-version: "3.12"
@@ -48,11 +47,11 @@ jobs:
         with:
           python-version: "3.12"
 
-      - name: '📦 Install Test Dependencies'
+      - name: Install dependencies
         run: uv sync --group test
         working-directory: ${{ matrix.working-directory }}
 
-      - name: '⚡ Run Benchmarks: ${{ matrix.working-directory }}'
+      - name: Run benchmarks ${{ matrix.working-directory }}
         uses: CodSpeedHQ/action@v3
         with:
           token: ${{ secrets.CODSPEED_TOKEN }}

.github/workflows/people.yml

@@ -1,6 +1,5 @@
-name: '👥 LangChain People'
-run-name: 'Update People Data'
-# This workflow updates the LangChain People data by fetching the latest information from the LangChain Git
+name: LangChain People
+
 on:
   schedule:
     - cron: "0 14 1 * *"
@@ -15,13 +14,13 @@ jobs:
     permissions:
       contents: write
     steps:
-      - name: '📋 Dump GitHub Context'
+      - name: Dump GitHub context
         env:
           GITHUB_CONTEXT: ${{ toJson(github) }}
         run: echo "$GITHUB_CONTEXT"
       - uses: actions/checkout@v4
       # Ref: https://github.com/actions/runner/issues/2033
-      - name: '🔧 Fix Git Safe Directory in Container'
+      - name: Fix git safe.directory in container
         run: mkdir -p /home/runner/work/_temp/_github_home && printf "[safe]\n\tdirectory = /github/workspace" > /home/runner/work/_temp/_github_home/.gitconfig
       - uses: ./.github/actions/people
         with:

.github/workflows/pr_lint.yml

@@ -4,7 +4,6 @@
 # Purpose:
 #   Enforces Conventional Commits format for pull request titles to maintain a
 #   clear, consistent, and machine-readable change history across our repository.
-#   This helps with automated changelog generation and semantic versioning.
 #
 # Enforced Commit Message Format (Conventional Commits 1.0.0):
 #   <type>[optional scope]: <description>
@@ -46,7 +45,7 @@
 #   • Conventional Commits spec: https://www.conventionalcommits.org/en/v1.0.0/
 # -----------------------------------------------------------------------------
 
-name: '🏷️ PR Title Lint'
+name: PR Title Lint
 
 permissions:
   pull-requests: read
@@ -56,12 +55,11 @@ on:
     types: [opened, edited, synchronize]
 
 jobs:
-  # Validates that PR title follows Conventional Commits specification
   lint-pr-title:
-    name: 'Validate PR Title Format'
+    name: Validate PR Title
     runs-on: ubuntu-latest
     steps:
-      - name: '✅ Validate Conventional Commits Format'
+      - name: Validate PR Title
         uses: amannn/action-semantic-pull-request@v5
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -83,7 +81,6 @@ jobs:
             core
             cli
             langchain
-            langchain_v1
             standard-tests
             text-splitters
             docs

.github/workflows/run_notebooks.yml

@@ -1,5 +1,5 @@
-name: '📓 Validate Documentation Notebooks'
-run-name: 'Test notebooks in ${{ inputs.working-directory  }}'
+name: Run Notebooks
+
 on:
   workflow_dispatch:
     inputs:
@@ -24,43 +24,43 @@ jobs:
   build:
     runs-on: ubuntu-latest
     if: github.repository == 'langchain-ai/langchain' || github.event_name != 'schedule'
-    name: '📑 Test Documentation Notebooks'
+    name: "Test docs"
     steps:
       - uses: actions/checkout@v4
 
-      - name: '🐍 Set up Python + UV'
+      - name: Set up Python + uv
         uses: "./.github/actions/uv_setup"
         with:
           python-version: ${{ github.event.inputs.python_version || '3.11' }}
 
-      - name: '🔐 Authenticate to Google Cloud'
+      - name: 'Authenticate to Google Cloud'
         id: 'auth'
         uses: google-github-actions/auth@v2
         with:
           credentials_json: '${{ secrets.GOOGLE_CREDENTIALS }}'
 
-      - name: '🔐 Configure AWS Credentials'
+      - name: Configure AWS Credentials
         uses: aws-actions/configure-aws-credentials@v4
         with:
           aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
           aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
           aws-region: ${{ secrets.AWS_REGION }}
 
-      - name: '📦 Install Dependencies'
+      - name: Install dependencies
         run: |
           uv sync --group dev --group test
 
-      - name: '📦 Pre-download Test Files'
+      - name: Pre-download files
         run: |
           uv run python docs/scripts/cache_data.py
           curl -s https://raw.githubusercontent.com/lerocha/chinook-database/master/ChinookDatabase/DataSources/Chinook_Sqlite.sql | sqlite3 docs/docs/how_to/Chinook.db
           cp docs/docs/how_to/Chinook.db docs/docs/tutorials/Chinook.db
 
-      - name: '🔧 Prepare Notebooks for CI'
+      - name: Prepare notebooks
         run: |
           uv run python docs/scripts/prepare_notebooks_for_ci.py --comment-install-cells --working-directory ${{ github.event.inputs.working-directory || 'all' }}
 
-      - name: '🚀 Execute Notebooks'
+      - name: Run notebooks
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           FIREWORKS_API_KEY: ${{ secrets.FIREWORKS_API_KEY }}

.github/workflows/scheduled_test.yml

@@ -1,8 +1,7 @@
-name: '⏰ Scheduled Integration Tests'
-run-name: "Run Integration Tests - ${{ inputs.working-directory-force || 'all libs' }} (Python ${{ inputs.python-version-force || '3.9, 3.11' }})"
+name: Scheduled Tests
 
 on:
-  workflow_dispatch:  # Allows maintainers to trigger the workflow manually in GitHub UI
+  workflow_dispatch:  # Allows to trigger the workflow manually in GitHub UI
     inputs:
       working-directory-force:
         type: string
@@ -11,7 +10,7 @@ on:
         type: string
         description: "Python version to use - defaults to 3.9 and 3.11 in matrix - example value: 3.9"
   schedule:
-    - cron:  '0 13 * * *'  # Runs daily at 1PM UTC (9AM EDT/6AM PDT)
+    - cron:  '0 13 * * *'
 
 permissions:
   contents: read
@@ -23,16 +22,14 @@ env:
   POETRY_LIBS: ("libs/partners/google-vertexai" "libs/partners/google-genai" "libs/partners/aws")
 
 jobs:
-  # Generate dynamic test matrix based on input parameters or defaults
-  # Only runs on the main repo (for scheduled runs) or when manually triggered
   compute-matrix:
     if: github.repository_owner == 'langchain-ai' || github.event_name != 'schedule'
     runs-on: ubuntu-latest
-    name: '📋 Compute Test Matrix'
+    name: Compute matrix
     outputs:
       matrix: ${{ steps.set-matrix.outputs.matrix }}
     steps:
-      - name: '🔢 Generate Python & Library Matrix'
+      - name: Set matrix
         id: set-matrix
         env:
           DEFAULT_LIBS: ${{ env.DEFAULT_LIBS }}
@@ -53,11 +50,9 @@ jobs:
           matrix="{\"python-version\": $python_version, \"working-directory\": $working_directory}"
           echo $matrix
           echo "matrix=$matrix" >> $GITHUB_OUTPUT
-  # Run integration tests against partner libraries with live API credentials
-  # Tests are run with both Poetry and UV depending on the library's setup
   build:
     if: github.repository_owner == 'langchain-ai' || github.event_name != 'schedule'
-    name: '🐍 Python ${{ matrix.python-version }}: ${{ matrix.working-directory }}'
+    name: Python ${{ matrix.python-version }} - ${{ matrix.working-directory }}
     runs-on: ubuntu-latest
     needs: [compute-matrix]
     timeout-minutes: 20
@@ -80,7 +75,7 @@ jobs:
           repository: langchain-ai/langchain-aws
           path: langchain-aws
 
-      - name: '📦 Organize External Libraries'
+      - name: Move libs
         run: |
           rm -rf \
             langchain/libs/partners/google-genai \
@@ -89,7 +84,7 @@ jobs:
           mv langchain-google/libs/vertexai langchain/libs/partners/google-vertexai
           mv langchain-aws/libs/aws langchain/libs/partners/aws
 
-      - name: '🐍 Set up Python ${{ matrix.python-version }} + Poetry'
+      - name: Set up Python ${{ matrix.python-version }} with poetry
         if: contains(env.POETRY_LIBS, matrix.working-directory)
         uses: "./langchain/.github/actions/poetry_setup"
         with:
@@ -98,40 +93,40 @@ jobs:
           working-directory: langchain/${{ matrix.working-directory }}
           cache-key: scheduled
 
-      - name: '🐍 Set up Python ${{ matrix.python-version }} + UV'
+      - name: Set up Python ${{ matrix.python-version }} + uv
         if: "!contains(env.POETRY_LIBS, matrix.working-directory)"
         uses: "./langchain/.github/actions/uv_setup"
         with:
           python-version: ${{ matrix.python-version }}
 
-      - name: '🔐 Authenticate to Google Cloud'
+      - name: 'Authenticate to Google Cloud'
         id: 'auth'
         uses: google-github-actions/auth@v2
         with:
           credentials_json: '${{ secrets.GOOGLE_CREDENTIALS }}'
 
-      - name: '🔐 Configure AWS Credentials'
+      - name: Configure AWS Credentials
         uses: aws-actions/configure-aws-credentials@v4
         with:
           aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
           aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
           aws-region: ${{ secrets.AWS_REGION }}
 
-      - name: '📦 Install Dependencies (Poetry)'
+      - name: Install dependencies (poetry)
         if: contains(env.POETRY_LIBS, matrix.working-directory)
         run: |
           echo "Running scheduled tests, installing dependencies with poetry..."
           cd langchain/${{ matrix.working-directory }}
           poetry install --with=test_integration,test
 
-      - name: '📦 Install Dependencies (UV)'
+      - name: Install dependencies (uv)
         if: "!contains(env.POETRY_LIBS, matrix.working-directory)"
         run: |
           echo "Running scheduled tests, installing dependencies with uv..."
           cd langchain/${{ matrix.working-directory }}
           uv sync --group test --group test_integration
 
-      - name: '🚀 Run Integration Tests'
+      - name: Run integration tests
         env:
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
@@ -160,15 +155,14 @@ jobs:
           cd langchain/${{ matrix.working-directory }}
           make integration_tests
 
-      - name: '🧹 Clean up External Libraries'
-        # Clean up external libraries to avoid affecting git status check
-        run: |
+      - name: Remove external libraries
+        run: | 
           rm -rf \
             langchain/libs/partners/google-genai \
             langchain/libs/partners/google-vertexai \
             langchain/libs/partners/aws
 
-      - name: '🧹 Verify Clean Working Directory'
+      - name: Ensure tests did not create additional files
         working-directory: langchain
         run: |
           set -eu

.gitignore

@@ -1,4 +1,5 @@
 .vs/
+.vscode/
 .idea/
 # Byte-compiled / optimized / DLL files
 __pycache__/

.markdownlint.json

@@ -1,14 +0,0 @@
-{
-  "MD013": false,
-  "MD024": {
-    "siblings_only": true
-  },
-  "MD025": false,
-  "MD033": false,
-  "MD034": false,
-  "MD036": false,
-  "MD041": false,
-  "MD046": {
-    "style": "fenced"
-  }
-}

.pre-commit-config.yaml

@@ -1,111 +1,111 @@
 repos:
-  - repo: local
-    hooks:
-      - id: core
-        name: format core
-        language: system
-        entry: make -C libs/core format
-        files: ^libs/core/
-        pass_filenames: false
-      - id: langchain
-        name: format langchain
-        language: system
-        entry: make -C libs/langchain format
-        files: ^libs/langchain/
-        pass_filenames: false
-      - id: standard-tests
-        name: format standard-tests
-        language: system
-        entry: make -C libs/standard-tests format
-        files: ^libs/standard-tests/
-        pass_filenames: false
-      - id: text-splitters
-        name: format text-splitters
-        language: system
-        entry: make -C libs/text-splitters format
-        files: ^libs/text-splitters/
-        pass_filenames: false
-      - id: anthropic
-        name: format partners/anthropic
-        language: system
-        entry: make -C libs/partners/anthropic format
-        files: ^libs/partners/anthropic/
-        pass_filenames: false
-      - id: chroma
-        name: format partners/chroma
-        language: system
-        entry: make -C libs/partners/chroma format
-        files: ^libs/partners/chroma/
-        pass_filenames: false
-      - id: couchbase
-        name: format partners/couchbase
-        language: system
-        entry: make -C libs/partners/couchbase format
-        files: ^libs/partners/couchbase/
-        pass_filenames: false
-      - id: exa
-        name: format partners/exa
-        language: system
-        entry: make -C libs/partners/exa format
-        files: ^libs/partners/exa/
-        pass_filenames: false
-      - id: fireworks
-        name: format partners/fireworks
-        language: system
-        entry: make -C libs/partners/fireworks format
-        files: ^libs/partners/fireworks/
-        pass_filenames: false
-      - id: groq
-        name: format partners/groq
-        language: system
-        entry: make -C libs/partners/groq format
-        files: ^libs/partners/groq/
-        pass_filenames: false
-      - id: huggingface
-        name: format partners/huggingface
-        language: system
-        entry: make -C libs/partners/huggingface format
-        files: ^libs/partners/huggingface/
-        pass_filenames: false
-      - id: mistralai
-        name: format partners/mistralai
-        language: system
-        entry: make -C libs/partners/mistralai format
-        files: ^libs/partners/mistralai/
-        pass_filenames: false
-      - id: nomic
-        name: format partners/nomic
-        language: system
-        entry: make -C libs/partners/nomic format
-        files: ^libs/partners/nomic/
-        pass_filenames: false
-      - id: ollama
-        name: format partners/ollama
-        language: system
-        entry: make -C libs/partners/ollama format
-        files: ^libs/partners/ollama/
-        pass_filenames: false
-      - id: openai
-        name: format partners/openai
-        language: system
-        entry: make -C libs/partners/openai format
-        files: ^libs/partners/openai/
-        pass_filenames: false
-      - id: prompty
-        name: format partners/prompty
-        language: system
-        entry: make -C libs/partners/prompty format
-        files: ^libs/partners/prompty/
-        pass_filenames: false
-      - id: qdrant
-        name: format partners/qdrant
-        language: system
-        entry: make -C libs/partners/qdrant format
-        files: ^libs/partners/qdrant/
-        pass_filenames: false
-      - id: root
-        name: format docs, cookbook
-        language: system
-        entry: make format
-        files: ^(docs|cookbook)/
-        pass_filenames: false
+- repo: local
+  hooks:
+    - id: core
+      name: format core
+      language: system
+      entry: make -C libs/core format
+      files: ^libs/core/
+      pass_filenames: false
+    - id: langchain
+      name: format langchain
+      language: system
+      entry: make -C libs/langchain format
+      files: ^libs/langchain/
+      pass_filenames: false
+    - id: standard-tests
+      name: format standard-tests
+      language: system
+      entry: make -C libs/standard-tests format
+      files: ^libs/standard-tests/
+      pass_filenames: false
+    - id: text-splitters
+      name: format text-splitters
+      language: system
+      entry: make -C libs/text-splitters format
+      files: ^libs/text-splitters/
+      pass_filenames: false
+    - id: anthropic
+      name: format partners/anthropic
+      language: system
+      entry: make -C libs/partners/anthropic format
+      files: ^libs/partners/anthropic/
+      pass_filenames: false
+    - id: chroma
+      name: format partners/chroma
+      language: system
+      entry: make -C libs/partners/chroma format
+      files: ^libs/partners/chroma/
+      pass_filenames: false
+    - id: couchbase
+      name: format partners/couchbase
+      language: system
+      entry: make -C libs/partners/couchbase format
+      files: ^libs/partners/couchbase/
+      pass_filenames: false
+    - id: exa
+      name: format partners/exa
+      language: system
+      entry: make -C libs/partners/exa format
+      files: ^libs/partners/exa/
+      pass_filenames: false
+    - id: fireworks
+      name: format partners/fireworks
+      language: system
+      entry: make -C libs/partners/fireworks format
+      files: ^libs/partners/fireworks/
+      pass_filenames: false
+    - id: groq
+      name: format partners/groq
+      language: system
+      entry: make -C libs/partners/groq format
+      files: ^libs/partners/groq/
+      pass_filenames: false
+    - id: huggingface
+      name: format partners/huggingface
+      language: system
+      entry: make -C libs/partners/huggingface format
+      files: ^libs/partners/huggingface/
+      pass_filenames: false
+    - id: mistralai
+      name: format partners/mistralai
+      language: system
+      entry: make -C libs/partners/mistralai format
+      files: ^libs/partners/mistralai/
+      pass_filenames: false
+    - id: nomic
+      name: format partners/nomic
+      language: system
+      entry: make -C libs/partners/nomic format
+      files: ^libs/partners/nomic/
+      pass_filenames: false
+    - id: ollama
+      name: format partners/ollama
+      language: system
+      entry: make -C libs/partners/ollama format
+      files: ^libs/partners/ollama/
+      pass_filenames: false
+    - id: openai
+      name: format partners/openai
+      language: system
+      entry: make -C libs/partners/openai format
+      files: ^libs/partners/openai/
+      pass_filenames: false
+    - id: prompty
+      name: format partners/prompty
+      language: system
+      entry: make -C libs/partners/prompty format
+      files: ^libs/partners/prompty/
+      pass_filenames: false
+    - id: qdrant
+      name: format partners/qdrant
+      language: system
+      entry: make -C libs/partners/qdrant format
+      files: ^libs/partners/qdrant/
+      pass_filenames: false
+    - id: root
+      name: format docs, cookbook
+      language: system
+      entry: make format
+      files: ^(docs|cookbook)/
+      pass_filenames: false

.readthedocs.yaml

@@ -13,7 +13,7 @@ build:
 
 # Build documentation in the docs/ directory with Sphinx
 sphinx:
-  configuration: docs/api_reference/conf.py
+   configuration: docs/api_reference/conf.py
 
 # If using Sphinx, optionally build your docs in additional formats such as PDF
 formats:
@@ -21,5 +21,5 @@ formats:
 
 # Optionally declare the Python requirements required to build your docs
 python:
-  install:
-    - requirements: docs/api_reference/requirements.txt
+   install:
+     - requirements: docs/api_reference/requirements.txt

.vscode/extensions.json

@@ -1,21 +0,0 @@
-{
-  "recommendations": [
-    "ms-python.python",
-    "charliermarsh.ruff",
-    "ms-python.mypy-type-checker",
-    "ms-toolsai.jupyter",
-    "ms-toolsai.jupyter-keymap",
-    "ms-toolsai.jupyter-renderers",
-    "ms-toolsai.vscode-jupyter-cell-tags",
-    "ms-toolsai.vscode-jupyter-slideshow",
-    "yzhang.markdown-all-in-one",
-    "davidanson.vscode-markdownlint",
-    "bierner.markdown-mermaid",
-    "bierner.markdown-preview-github-styles",
-    "eamodio.gitlens",
-    "github.vscode-pull-request-github",
-    "github.vscode-github-actions",
-    "redhat.vscode-yaml",
-    "editorconfig.editorconfig",
-  ],
-}

.vscode/settings.json

@@ -1,82 +0,0 @@
-{
-  "python.analysis.include": [
-    "libs/**",
-    "docs/**",
-    "cookbook/**"
-  ],
-  "python.analysis.exclude": [
-    "**/node_modules",
-    "**/__pycache__",
-    "**/.pytest_cache",
-    "**/.*",
-    "_dist/**",
-    "docs/_build/**",
-    "docs/api_reference/_build/**"
-  ],
-  "python.analysis.autoImportCompletions": true,
-  "python.analysis.typeCheckingMode": "basic",
-  "python.testing.cwd": "${workspaceFolder}",
-  "python.linting.enabled": true,
-  "python.linting.ruffEnabled": true,
-  "[python]": {
-    "editor.formatOnSave": true,
-    "editor.codeActionsOnSave": {
-      "source.organizeImports.ruff": "explicit",
-      "source.fixAll": "explicit"
-    },
-    "editor.defaultFormatter": "charliermarsh.ruff"
-  },
-  "editor.rulers": [
-    88
-  ],
-  "editor.tabSize": 4,
-  "editor.insertSpaces": true,
-  "editor.trimAutoWhitespace": true,
-  "files.trimTrailingWhitespace": true,
-  "files.insertFinalNewline": true,
-  "files.exclude": {
-    "**/__pycache__": true,
-    "**/.pytest_cache": true,
-    "**/*.pyc": true,
-    "**/.mypy_cache": true,
-    "**/.ruff_cache": true,
-    "_dist/**": true,
-    "docs/_build/**": true,
-    "docs/api_reference/_build/**": true,
-    "**/node_modules": true,
-    "**/.git": false
-  },
-  "search.exclude": {
-    "**/__pycache__": true,
-    "**/*.pyc": true,
-    "_dist/**": true,
-    "docs/_build/**": true,
-    "docs/api_reference/_build/**": true,
-    "**/node_modules": true,
-    "**/.git": true,
-    "uv.lock": true,
-    "yarn.lock": true
-  },
-  "git.autofetch": true,
-  "git.enableSmartCommit": true,
-  "jupyter.askForKernelRestart": false,
-  "jupyter.interactiveWindow.textEditor.executeSelection": true,
-  "[markdown]": {
-    "editor.wordWrap": "on",
-    "editor.quickSuggestions": {
-      "comments": "off",
-      "strings": "off",
-      "other": "off"
-    }
-  },
-  "[yaml]": {
-    "editor.tabSize": 2,
-    "editor.insertSpaces": true
-  },
-  "[json]": {
-    "editor.tabSize": 2,
-    "editor.insertSpaces": true
-  },
-  "python.terminal.activateEnvironment": false,
-  "python.defaultInterpreterPath": "./.venv/bin/python"
-}

CLAUDE.md

@@ -1,325 +0,0 @@
-# Global Development Guidelines for LangChain Projects
-
-## Core Development Principles
-
-### 1. Maintain Stable Public Interfaces ⚠️ CRITICAL
-
-**Always attempt to preserve function signatures, argument positions, and names for exported/public methods.**
-
-❌ **Bad - Breaking Change:**
-
-```python
-def get_user(id, verbose=False):  # Changed from `user_id`
-    pass
-```
-
-✅ **Good - Stable Interface:**
-
-```python
-def get_user(user_id: str, verbose: bool = False) -> User:
-    """Retrieve user by ID with optional verbose output."""
-    pass
-```
-
-**Before making ANY changes to public APIs:**
-
-- Check if the function/class is exported in `__init__.py`
-- Look for existing usage patterns in tests and examples
-- Use keyword-only arguments for new parameters: `*, new_param: str = "default"`
-- Mark experimental features clearly with docstring warnings (using reStructuredText, like `.. warning::`)
-
-🧠 *Ask yourself:* "Would this change break someone's code if they used it last week?"
-
-### 2. Code Quality Standards
-
-**All Python code MUST include type hints and return types.**
-
-❌ **Bad:**
-
-```python
-def p(u, d):
-    return [x for x in u if x not in d]
-```
-
-✅ **Good:**
-
-```python
-def filter_unknown_users(users: list[str], known_users: set[str]) -> list[str]:
-    """Filter out users that are not in the known users set.
-
-    Args:
-        users: List of user identifiers to filter.
-        known_users: Set of known/valid user identifiers.
-
-    Returns:
-        List of users that are not in the known_users set.
-    """
-    return [user for user in users if user not in known_users]
-```
-
-**Style Requirements:**
-
-- Use descriptive, **self-explanatory variable names**. Avoid overly short or cryptic identifiers.
-- Attempt to break up complex functions (>20 lines) into smaller, focused functions where it makes sense
-- Avoid unnecessary abstraction or premature optimization
-- Follow existing patterns in the codebase you're modifying
-
-### 3. Testing Requirements
-
-**Every new feature or bugfix MUST be covered by unit tests.**
-
-**Test Organization:**
-
-- Unit tests: `tests/unit_tests/` (no network calls allowed)
-- Integration tests: `tests/integration_tests/` (network calls permitted)
-- Use `pytest` as the testing framework
-
-**Test Quality Checklist:**
-
-- [ ] Tests fail when your new logic is broken
-- [ ] Happy path is covered
-- [ ] Edge cases and error conditions are tested
-- [ ] Use fixtures/mocks for external dependencies
-- [ ] Tests are deterministic (no flaky tests)
-
-Checklist questions:
-
-- [ ] Does the test suite fail if your new logic is broken?
-- [ ] Are all expected behaviors exercised (happy path, invalid input, etc)?
-- [ ] Do tests use fixtures or mocks where needed?
-
-```python
-def test_filter_unknown_users():
-    """Test filtering unknown users from a list."""
-    users = ["alice", "bob", "charlie"]
-    known_users = {"alice", "bob"}
-
-    result = filter_unknown_users(users, known_users)
-
-    assert result == ["charlie"]
-    assert len(result) == 1
-```
-
-### 4. Security and Risk Assessment
-
-**Security Checklist:**
-
-- No `eval()`, `exec()`, or `pickle` on user-controlled input
-- Proper exception handling (no bare `except:`) and use a `msg` variable for error messages
-- Remove unreachable/commented code before committing
-- Race conditions or resource leaks (file handles, sockets, threads).
-- Ensure proper resource cleanup (file handles, connections)
-
-❌ **Bad:**
-
-```python
-def load_config(path):
-    with open(path) as f:
-        return eval(f.read())  # ⚠️ Never eval config
-```
-
-✅ **Good:**
-
-```python
-import json
-
-def load_config(path: str) -> dict:
-    with open(path) as f:
-        return json.load(f)
-```
-
-### 5. Documentation Standards
-
-**Use Google-style docstrings with Args section for all public functions.**
-
-❌ **Insufficient Documentation:**
-
-```python
-def send_email(to, msg):
-    """Send an email to a recipient."""
-```
-
-✅ **Complete Documentation:**
-
-```python
-def send_email(to: str, msg: str, *, priority: str = "normal") -> bool:
-    """
-    Send an email to a recipient with specified priority.
-
-    Args:
-        to: The email address of the recipient.
-        msg: The message body to send.
-        priority: Email priority level (``'low'``, ``'normal'``, ``'high'``).
-
-    Returns:
-        True if email was sent successfully, False otherwise.
-
-    Raises:
-        InvalidEmailError: If the email address format is invalid.
-        SMTPConnectionError: If unable to connect to email server.
-    """
-```
-
-**Documentation Guidelines:**
-
-- Types go in function signatures, NOT in docstrings
-- Focus on "why" rather than "what" in descriptions
-- Document all parameters, return values, and exceptions
-- Keep descriptions concise but clear
-- Use reStructuredText for docstrings to enable rich formatting
-
-📌 *Tip:* Keep descriptions concise but clear. Only document return values if non-obvious.
-
-### 6. Architectural Improvements
-
-**When you encounter code that could be improved, suggest better designs:**
-
-❌ **Poor Design:**
-
-```python
-def process_data(data, db_conn, email_client, logger):
-    # Function doing too many things
-    validated = validate_data(data)
-    result = db_conn.save(validated)
-    email_client.send_notification(result)
-    logger.log(f"Processed {len(data)} items")
-    return result
-```
-
-✅ **Better Design:**
-
-```python
-@dataclass
-class ProcessingResult:
-    """Result of data processing operation."""
-    items_processed: int
-    success: bool
-    errors: List[str] = field(default_factory=list)
-
-class DataProcessor:
-    """Handles data validation, storage, and notification."""
-
-    def __init__(self, db_conn: Database, email_client: EmailClient):
-        self.db = db_conn
-        self.email = email_client
-
-    def process(self, data: List[dict]) -> ProcessingResult:
-        """Process and store data with notifications."""
-        validated = self._validate_data(data)
-        result = self.db.save(validated)
-        self._notify_completion(result)
-        return result
-```
-
-**Design Improvement Areas:**
-
-If there's a **cleaner**, **more scalable**, or **simpler** design, highlight it and suggest improvements that would:
-
-- Reduce code duplication through shared utilities
-- Make unit testing easier
-- Improve separation of concerns (single responsibility)
-- Make unit testing easier through dependency injection
-- Add clarity without adding complexity
-- Prefer dataclasses for structured data
-
-## Development Tools & Commands
-
-### Package Management
-
-```bash
-# Add package
-uv add package-name
-
-# Sync project dependencies
-uv sync
-uv lock
-```
-
-### Testing
-
-```bash
-# Run unit tests (no network)
-make test
-
-# Don't run integration tests, as API keys must be set
-
-# Run specific test file
-uv run --group test pytest tests/unit_tests/test_specific.py
-```
-
-### Code Quality
-
-```bash
-# Lint code
-make lint
-
-# Format code
-make format
-
-# Type checking
-uv run --group lint mypy .
-```
-
-### Dependency Management Patterns
-
-**Local Development Dependencies:**
-
-```toml
-[tool.uv.sources]
-langchain-core = { path = "../core", editable = true }
-langchain-tests = { path = "../standard-tests", editable = true }
-```
-
-**For tools, use the `@tool` decorator from `langchain_core.tools`:**
-
-```python
-from langchain_core.tools import tool
-
-@tool
-def search_database(query: str) -> str:
-    """Search the database for relevant information.
-
-    Args:
-        query: The search query string.
-    """
-    # Implementation here
-    return results
-```
-
-## Commit Standards
-
-**Use Conventional Commits format for PR titles:**
-
-- `feat(core): add multi-tenant support`
-- `fix(cli): resolve flag parsing error`
-- `docs: update API usage examples`
-- `docs(openai): update API usage examples`
-
-## Framework-Specific Guidelines
-
-- Follow the existing patterns in `langchain-core` for base abstractions
-- Use `langchain_core.callbacks` for execution tracking
-- Implement proper streaming support where applicable
-- Avoid deprecated components like legacy `LLMChain`
-
-### Partner Integrations
-
-- Follow the established patterns in existing partner libraries
-- Implement standard interfaces (`BaseChatModel`, `BaseEmbeddings`, etc.)
-- Include comprehensive integration tests
-- Document API key requirements and authentication
-
----
-
-## Quick Reference Checklist
-
-Before submitting code changes:
-
-- [ ] **Breaking Changes**: Verified no public API changes
-- [ ] **Type Hints**: All functions have complete type annotations
-- [ ] **Tests**: New functionality is fully tested
-- [ ] **Security**: No dangerous patterns (eval, silent failures, etc.)
-- [ ] **Documentation**: Google-style docstrings for public functions
-- [ ] **Code Quality**: `make lint` and `make format` pass
-- [ ] **Architecture**: Suggested improvements where applicable
-- [ ] **Commit Message**: Follows Conventional Commits format

MIGRATE.md

@@ -7,5 +7,5 @@ Please see the following guides for migrating LangChain code:
 * Migrating from [LangChain 0.0.x Chains](https://python.langchain.com/docs/versions/migrating_chains/)
 * Upgrade to [LangGraph Memory](https://python.langchain.com/docs/versions/migrating_memory/)
 
-The [LangChain CLI](https://python.langchain.com/docs/versions/v0_3/#migrate-using-langchain-cli) can help you automatically upgrade your code to use non-deprecated imports.
+The [LangChain CLI](https://python.langchain.com/docs/versions/v0_3/#migrate-using-langchain-cli) can help you automatically upgrade your code to use non-deprecated imports. 
 This will be especially helpful if you're still on either version 0.0.x or 0.1.x of LangChain.

Makefile

@@ -8,6 +8,9 @@ help: Makefile
 	@printf "\n\033[1mUsage: make <TARGETS> ...\033[0m\n\n\033[1mTargets:\033[0m\n\n"
 	@sed -n 's/^## //p' $< | awk -F':' '{printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}' | sort | sed -e 's/^/  /'
 
+## all: Default target, shows help.
+all: help
+
 ## clean: Clean documentation and API documentation artifacts.
 clean: docs_clean api_docs_clean
 
@@ -16,79 +19,49 @@ clean: docs_clean api_docs_clean
 ######################
 
 ## docs_build: Build the documentation.
-docs_build: docs_clean
-	@echo "📚 Building LangChain documentation..."
+docs_build:
 	cd docs && make build
-	@echo "✅ Documentation build complete!"
 
 ## docs_clean: Clean the documentation build artifacts.
 docs_clean:
-	@echo "🧹 Cleaning documentation artifacts..."
 	cd docs && make clean
-	@echo "✅ LangChain documentation cleaned"
 
 ## docs_linkcheck: Run linkchecker on the documentation.
 docs_linkcheck:
-	@echo "🔗 Checking documentation links..."
-	@if [ -d _dist/docs ]; then \
-		uv run --group test linkchecker _dist/docs/ --ignore-url node_modules; \
-	else \
-		echo "⚠️  Documentation not built. Run 'make docs_build' first."; \
-		exit 1; \
-	fi
-	@echo "✅ Link check complete"
+	uv run --no-group test linkchecker _dist/docs/ --ignore-url node_modules
 
 ## api_docs_build: Build the API Reference documentation.
-api_docs_build: clean
-	@echo "📖 Building API Reference documentation..."
-	uv pip install -e libs/cli
-	uv run --group docs python docs/api_reference/create_api_rst.py
-	cd docs/api_reference && uv run --group docs make html
-	uv run --group docs python docs/api_reference/scripts/custom_formatter.py docs/api_reference/_build/html/
-	@echo "✅ API documentation built"
-	@echo "🌐 Opening documentation in browser..."
-	open docs/api_reference/_build/html/reference.html
+api_docs_build:
+	uv run --no-group test python docs/api_reference/create_api_rst.py
+	cd docs/api_reference && uv run --no-group test make html
+	uv run --no-group test python docs/api_reference/scripts/custom_formatter.py docs/api_reference/_build/html/
 
 API_PKG ?= text-splitters
 
-api_docs_quick_preview: clean
-	@echo "⚡ Building quick API preview for $(API_PKG)..."
-	uv run --group docs python docs/api_reference/create_api_rst.py $(API_PKG)
-	cd docs/api_reference && uv run --group docs make html
-	uv run --group docs python docs/api_reference/scripts/custom_formatter.py docs/api_reference/_build/html/
-	@echo "🌐 Opening preview in browser..."
+api_docs_quick_preview:
+	uv run --no-group test python docs/api_reference/create_api_rst.py $(API_PKG)
+	cd docs/api_reference && uv run make html
+	uv run --no-group test python docs/api_reference/scripts/custom_formatter.py docs/api_reference/_build/html/
 	open docs/api_reference/_build/html/reference.html
 
 ## api_docs_clean: Clean the API Reference documentation build artifacts.
 api_docs_clean:
-	@echo "🧹 Cleaning API documentation artifacts..."
 	find ./docs/api_reference -name '*_api_reference.rst' -delete
 	git clean -fdX ./docs/api_reference
 	rm -f docs/api_reference/index.md
-	@echo "✅ API documentation cleaned"
+	
 
 ## api_docs_linkcheck: Run linkchecker on the API Reference documentation.
 api_docs_linkcheck:
-	@echo "🔗 Checking API documentation links..."
-	@if [ -f docs/api_reference/_build/html/index.html ]; then \
-		uv run --group test linkchecker docs/api_reference/_build/html/index.html; \
-	else \
-		echo "⚠️  API documentation not built. Run 'make api_docs_build' first."; \
-		exit 1; \
-	fi
-	@echo "✅ API link check complete"
+	uv run --no-group test linkchecker docs/api_reference/_build/html/index.html
 
 ## spell_check: Run codespell on the project.
 spell_check:
-	@echo "✏️ Checking spelling across project..."
-	uv run --group codespell codespell --toml pyproject.toml
-	@echo "✅ Spell check complete"
+	uv run --no-group test codespell --toml pyproject.toml
 
 ## spell_fix: Run codespell on the project and fix the errors.
 spell_fix:
-	@echo "✏️ Fixing spelling errors across project..."
-	uv run --group codespell codespell --toml pyproject.toml -w
-	@echo "✅ Spelling errors fixed"
+	uv run --no-group test codespell --toml pyproject.toml -w
 
 ######################
 # LINTING AND FORMATTING
@@ -96,7 +69,6 @@ spell_fix:
 
 ## lint: Run linting on the project.
 lint lint_package lint_tests:
-	@echo "🔍 Running code linting and checks..."
 	uv run --group lint ruff check docs cookbook
 	uv run --group lint ruff format docs cookbook cookbook --diff
 	git --no-pager grep 'from langchain import' docs cookbook | grep -vE 'from langchain import (hub)' && echo "Error: no importing langchain from root in docs, except for hub" && exit 1 || exit 0
@@ -104,16 +76,11 @@ lint lint_package lint_tests:
 	git --no-pager grep 'api.python.langchain.com' -- docs/docs ':!docs/docs/additional_resources/arxiv_references.mdx' ':!docs/docs/integrations/document_loaders/sitemap.ipynb' || exit 0 && \
 	echo "Error: you should link python.langchain.com/api_reference, not api.python.langchain.com in the docs" && \
 	exit 1
-	@echo "✅ Linting complete"
 
 ## format: Format the project files.
 format format_diff:
-	@echo "🎨 Formatting project files..."
 	uv run --group lint ruff format docs cookbook
 	uv run --group lint ruff check --fix docs cookbook
-	@echo "✅ Formatting complete"
 
 update-package-downloads:
-	@echo "📊 Updating package download statistics..."
 	uv run python docs/scripts/packages_yml_get_downloads.py
-	@echo "✅ Package downloads updated"

README.md

@@ -9,13 +9,15 @@
 </div>
 
 [![Release Notes](https://img.shields.io/github/release/langchain-ai/langchain?style=flat-square)](https://github.com/langchain-ai/langchain/releases)
+[![CI](https://github.com/langchain-ai/langchain/actions/workflows/check_diffs.yml/badge.svg)](https://github.com/langchain-ai/langchain/actions/workflows/check_diffs.yml)
 [![PyPI - License](https://img.shields.io/pypi/l/langchain-core?style=flat-square)](https://opensource.org/licenses/MIT)
-[![PyPI - Downloads](https://img.shields.io/pepy/dt/langchain)](https://pypistats.org/packages/langchain-core)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/langchain-core?style=flat-square)](https://pypistats.org/packages/langchain-core)
 [![GitHub star chart](https://img.shields.io/github/stars/langchain-ai/langchain?style=flat-square)](https://star-history.com/#langchain-ai/langchain)
+[![Open Issues](https://img.shields.io/github/issues-raw/langchain-ai/langchain?style=flat-square)](https://github.com/langchain-ai/langchain/issues)
 [![Open in Dev Containers](https://img.shields.io/static/v1?label=Dev%20Containers&message=Open&color=blue&logo=visualstudiocode&style=flat-square)](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/langchain-ai/langchain)
-[<img src="https://github.com/codespaces/badge.svg" alt="Open in Github Codespace" title="Open in Github Codespace" width="150" height="20">](https://codespaces.new/langchain-ai/langchain)
-[![CodSpeed Badge](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://codspeed.io/langchain-ai/langchain)
+[<img src="https://github.com/codespaces/badge.svg" title="Open in Github Codespace" width="150" height="20">](https://codespaces.new/langchain-ai/langchain)
 [![Twitter](https://img.shields.io/twitter/url/https/twitter.com/langchainai.svg?style=social&label=Follow%20%40LangChainAI)](https://twitter.com/langchainai)
+[![CodSpeed Badge](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://codspeed.io/langchain-ai/langchain)
 
 > [!NOTE]
 > Looking for the JS/TS library? Check out [LangChain.js](https://github.com/langchain-ai/langchainjs).
@@ -38,12 +40,11 @@ controllable agent workflows.
 ## Why use LangChain?
 
 LangChain helps developers build applications powered by LLMs through a standard
-interface for models, embeddings, vector stores, and more.
+interface for models, embeddings, vector stores, and more. 
 
 Use LangChain for:
-
 - **Real-time data augmentation**. Easily connect LLMs to diverse data sources and
-external/internal systems, drawing from LangChain’s vast library of integrations with
+external / internal systems, drawing from LangChain’s vast library of integrations with
 model providers, tools, vector stores, retrievers, and more.
 - **Model interoperability**. Swap models in and out as your engineering team
 experiments to find the best choice for your application’s needs. As the industry
@@ -51,14 +52,13 @@ frontier evolves, adapt quickly — LangChain’s abstractions keep you moving w
 losing momentum.
 
 ## LangChain’s ecosystem
-
 While the LangChain framework can be used standalone, it also integrates seamlessly
 with any LangChain product, giving developers a full suite of tools when building LLM
-applications.
+applications. 
 
 To improve your LLM application development, pair LangChain with:
 
-- [LangSmith](https://www.langchain.com/langsmith) - Helpful for agent evals and
+- [LangSmith](http://www.langchain.com/langsmith) - Helpful for agent evals and
 observability. Debug poor-performing LLM app runs, evaluate agent trajectories, gain
 visibility in production, and improve performance over time.
 - [LangGraph](https://langchain-ai.github.io/langgraph/) - Build agents that can
@@ -66,13 +66,13 @@ reliably handle complex tasks with LangGraph, our low-level agent orchestration
 framework. LangGraph offers customizable architecture, long-term memory, and
 human-in-the-loop workflows — and is trusted in production by companies like LinkedIn,
 Uber, Klarna, and GitLab.
-- [LangGraph Platform](https://docs.langchain.com/langgraph-platform) - Deploy
-and scale agents effortlessly with a purpose-built deployment platform for long-running, stateful workflows. Discover, reuse, configure, and share agents across
+- [LangGraph Platform](https://langchain-ai.github.io/langgraph/concepts/langgraph_platform/) - Deploy
+and scale agents effortlessly with a purpose-built deployment platform for long
+running, stateful workflows. Discover, reuse, configure, and share agents across
 teams — and iterate quickly with visual prototyping in
 [LangGraph Studio](https://langchain-ai.github.io/langgraph/concepts/langgraph_studio/).
 
 ## Additional resources
-
 - [Tutorials](https://python.langchain.com/docs/tutorials/): Simple walkthroughs with
 guided examples on getting started with LangChain.
 - [How-to Guides](https://python.langchain.com/docs/how_to/): Quick, actionable code
@@ -82,4 +82,3 @@ concepts behind the LangChain framework.
 - [LangChain Forum](https://forum.langchain.com/): Connect with the community and share all of your technical questions, ideas, and feedback.
 - [API Reference](https://python.langchain.com/api_reference/): Detailed reference on
 navigating base packages and integrations for LangChain.
-- [Chat LangChain](https://chat.langchain.com/): Ask questions & chat with our documentation.

SECURITY.md

@@ -4,14 +4,13 @@ LangChain has a large ecosystem of integrations with various external resources
 
 ## Best practices
 
-When building such applications, developers should remember to follow good security practices:
+When building such applications developers should remember to follow good security practices:
 
-* [**Limit Permissions**](https://en.wikipedia.org/wiki/Principle_of_least_privilege): Scope permissions specifically to the application's need. Granting broad or excessive permissions can introduce significant security vulnerabilities. To avoid such vulnerabilities, consider using read-only credentials, disallowing access to sensitive resources, using sandboxing techniques (such as running inside a container), specifying proxy configurations to control external requests, etc., as appropriate for your application.
+* [**Limit Permissions**](https://en.wikipedia.org/wiki/Principle_of_least_privilege): Scope permissions specifically to the application's need. Granting broad or excessive permissions can introduce significant security vulnerabilities. To avoid such vulnerabilities, consider using read-only credentials, disallowing access to sensitive resources, using sandboxing techniques (such as running inside a container), specifying proxy configurations to control external requests, etc. as appropriate for your application.
 * **Anticipate Potential Misuse**: Just as humans can err, so can Large Language Models (LLMs). Always assume that any system access or credentials may be used in any way allowed by the permissions they are assigned. For example, if a pair of database credentials allows deleting data, it's safest to assume that any LLM able to use those credentials may in fact delete data.
 * [**Defense in Depth**](https://en.wikipedia.org/wiki/Defense_in_depth_(computing)): No security technique is perfect. Fine-tuning and good chain design can reduce, but not eliminate, the odds that a Large Language Model (LLM) may make a mistake. It's best to combine multiple layered security approaches rather than relying on any single layer of defense to ensure security. For example: use both read-only permissions and sandboxing to ensure that LLMs are only able to access data that is explicitly meant for them to use.
 
 Risks of not doing so include, but are not limited to:
-
 * Data corruption or loss.
 * Unauthorized access to confidential information.
 * Compromised performance or availability of critical resources.
@@ -28,11 +27,11 @@ design and secure your applications.
 
 ## Reporting OSS Vulnerabilities
 
-LangChain is partnered with [huntr by Protect AI](https://huntr.com/) to provide
-a bounty program for our open source projects.
+LangChain is partnered with [huntr by Protect AI](https://huntr.com/) to provide 
+a bounty program for our open source projects. 
 
-Please report security vulnerabilities associated with the LangChain
-open source projects at [huntr](https://huntr.com/bounties/disclose/?target=https%3A%2F%2Fgithub.com%2Flangchain-ai%2Flangchain&validSearch=true).
+Please report security vulnerabilities associated with the LangChain 
+open source projects [here](https://huntr.com/bounties/disclose/?target=https%3A%2F%2Fgithub.com%2Flangchain-ai%2Flangchain&validSearch=true).
 
 Before reporting a vulnerability, please review:
 
@@ -46,38 +45,39 @@ Before reporting a vulnerability, please review:
 
 The following packages and repositories are eligible for bug bounties:
 
-* langchain-core
-* langchain (see exceptions)
-* langchain-community (see exceptions)
-* langgraph
-* langserve
+- langchain-core
+- langchain (see exceptions)
+- langchain-community (see exceptions)
+- langgraph
+- langserve
 
 ### Out of Scope Targets
 
 All out of scope targets defined by huntr as well as:
 
-* **langchain-experimental**: This repository is for experimental code and is not
+- **langchain-experimental**: This repository is for experimental code and is not
   eligible for bug bounties (see [package warning](https://pypi.org/project/langchain-experimental/)), bug reports to it will be marked as interesting or waste of
   time and published with no bounty attached.
-* **tools**: Tools in either langchain or langchain-community are not eligible for bug
+- **tools**: Tools in either langchain or langchain-community are not eligible for bug
   bounties. This includes the following directories
-  * libs/langchain/langchain/tools
-  * libs/community/langchain_community/tools
-  * Please review the [Best Practices](#best-practices)
+  - libs/langchain/langchain/tools
+  - libs/community/langchain_community/tools
+  - Please review the [Best Practices](#best-practices)
     for more details, but generally tools interact with the real world. Developers are
     expected to understand the security implications of their code and are responsible
     for the security of their tools.
-* Code documented with security notices. This will be decided on a case-by-case basis, but likely will not be eligible for a bounty as the code is already
+- Code documented with security notices. This will be decided done on a case by
+  case basis, but likely will not be eligible for a bounty as the code is already
   documented with guidelines for developers that should be followed for making their
   application secure.
-* Any LangSmith related repositories or APIs (see [Reporting LangSmith Vulnerabilities](#reporting-langsmith-vulnerabilities)).
+- Any LangSmith related repositories or APIs (see [Reporting LangSmith Vulnerabilities](#reporting-langsmith-vulnerabilities)).
 
 ## Reporting LangSmith Vulnerabilities
 
 Please report security vulnerabilities associated with LangSmith by email to `security@langchain.dev`.
 
-* LangSmith site: [https://smith.langchain.com](https://smith.langchain.com)
-* SDK client: [https://github.com/langchain-ai/langsmith-sdk](https://github.com/langchain-ai/langsmith-sdk)
+- LangSmith site: https://smith.langchain.com
+- SDK client: https://github.com/langchain-ai/langsmith-sdk
 
 ### Other Security Concerns
 

cookbook/Multi_modal_RAG_google.ipynb

@@ -144,7 +144,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "id": "kWDWfSDBMPl8",
    "metadata": {},
    "outputs": [
@@ -185,7 +185,7 @@
     "    )\n",
     "    # Text summary chain\n",
     "    model = VertexAI(\n",
-    "        temperature=0, model_name=\"gemini-2.5-flash\", max_tokens=1024\n",
+    "        temperature=0, model_name=\"gemini-2.0-flash-lite-001\", max_tokens=1024\n",
     "    ).with_fallbacks([empty_response])\n",
     "    summarize_chain = {\"element\": lambda x: x} | prompt | model | StrOutputParser()\n",
     "\n",
@@ -235,7 +235,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "id": "PeK9bzXv3olF",
    "metadata": {},
    "outputs": [],
@@ -254,7 +254,7 @@
     "\n",
     "def image_summarize(img_base64, prompt):\n",
     "    \"\"\"Make image summary\"\"\"\n",
-    "    model = ChatVertexAI(model=\"gemini-2.5-flash\", max_tokens=1024)\n",
+    "    model = ChatVertexAI(model=\"gemini-2.0-flash\", max_tokens=1024)\n",
     "\n",
     "    msg = model.invoke(\n",
     "        [\n",
@@ -431,7 +431,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 9,
    "id": "GlwCErBaCKQW",
    "metadata": {},
    "outputs": [],
@@ -553,7 +553,7 @@
     "    \"\"\"\n",
     "\n",
     "    # Multi-modal LLM\n",
-    "    model = ChatVertexAI(temperature=0, model_name=\"gemini-2.5-flash\", max_tokens=1024)\n",
+    "    model = ChatVertexAI(temperature=0, model_name=\"gemini-2.0-flash\", max_tokens=1024)\n",
     "\n",
     "    # RAG pipeline\n",
     "    chain = (\n",

cookbook/README.md

@@ -63,4 +63,4 @@ Notebook | Description
 [rag-locally-on-intel-cpu.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/rag-locally-on-intel-cpu.ipynb) | Perform Retrieval-Augmented-Generation (RAG) on locally downloaded open-source models using langchain and open source tools and execute it on Intel Xeon CPU. We showed an example of how to apply RAG on Llama 2 model and enable it to answer the queries related to Intel Q1 2024 earnings release.
 [visual_RAG_vdms.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/visual_RAG_vdms.ipynb) | Performs Visual Retrieval-Augmented-Generation (RAG) using videos and scene descriptions generated by open source models.
 [contextual_rag.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/contextual_rag.ipynb) | Performs contextual retrieval-augmented generation (RAG) prepending chunk-specific explanatory context to each chunk before embedding.
-[rag-agents-locally-on-intel-cpu.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/local_rag_agents_intel_cpu.ipynb) | Build a RAG agent locally with open source models that routes questions through one of two paths to find answers. The agent generates answers based on documents retrieved from either the vector database or retrieved from web search. If the vector database lacks relevant information, the agent opts for web search. Open-source models for LLM and embeddings are used locally on an Intel Xeon CPU to execute this pipeline.
+[rag-agents-locally-on-intel-cpu.ipynb](https://github.com/langchain-ai/langchain/tree/master/cookbook/local_rag_agents_intel_cpu.ipynb) | Build a RAG agent locally with open source models that routes questions through one of two paths to find answers. The agent generates answers based on documents retrieved from either the vector database or retrieved from web search. If the vector database lacks relevant information, the agent opts for web search. Open-source models for LLM and embeddings are used locally on an Intel Xeon CPU to execute this pipeline.

cookbook/img-to_img-search_CLIP_ChromaDB.ipynb

@@ -20,7 +20,11 @@
    "cell_type": "markdown",
    "id": "5939a54c-3198-4ba4-8346-1cc088c473c0",
    "metadata": {},
-   "source": "##### You can embed text in the same VectorDB space as images, and retrieve text and images as well based on input text or image.\n##### Following link demonstrates that.\n<a> https://python.langchain.com/v0.2/docs/integrations/text_embedding/open_clip/ </a>"
+   "source": [
+    "##### You can embed text in the same VectorDB space as images, and retreive text and images as well based on input text or image.\n",
+    "##### Following link demonstrates that.\n",
+    "<a> https://python.langchain.com/v0.2/docs/integrations/text_embedding/open_clip/ </a>"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -596,4 +600,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}

cookbook/langgraph_agentic_rag.ipynb

@@ -79,17 +79,6 @@
     "tool_executor = ToolExecutor(tools)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "168152fc",
-   "metadata": {},
-   "source": [
-    "📘 **Note on `SystemMessage` usage with LangGraph-based agents**\n",
-    "\n",
-    "When constructing the `messages` list for an agent, you *must* manually include any `SystemMessage`s.\n",
-    "Unlike some agent executors in LangChain that set a default, LangGraph requires explicit inclusion."
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "fe6e8f78-1ef7-42ad-b2bf-835ed5850553",

cookbook/rag-locally-on-intel-cpu.ipynb

@@ -552,7 +552,9 @@
    "cell_type": "markdown",
    "id": "77deb6a0-0950-450a-916a-f2a029676c20",
    "metadata": {},
-   "source": "**Appending all retrieved documents in a single document**"
+   "source": [
+    "**Appending all retreived documents in a single document**"
+   ]
   },
   {
    "cell_type": "code",
@@ -756,4 +758,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}

cookbook/tool_call_messages.ipynb

@@ -34,7 +34,7 @@
     "tools = [multiply, exponentiate, add]\n",
     "\n",
     "gpt35 = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0).bind_tools(tools)\n",
-    "claude3 = ChatAnthropic(model=\"claude-3-7-sonnet-20250219\").bind_tools(tools)\n",
+    "claude3 = ChatAnthropic(model=\"claude-3-sonnet-20240229\").bind_tools(tools)\n",
     "llm_with_tools = gpt35.configurable_alternatives(\n",
     "    ConfigurableField(id=\"llm\"), default_key=\"gpt35\", claude3=claude3\n",
     ")"
@@ -113,15 +113,14 @@
     {
      "data": {
       "text/plain": [
-       "{'messages': [HumanMessage(content=\"what's 3 plus 5 raised to the 2.743. also what's 17.24 - 918.1241\", additional_kwargs={}, response_metadata={}),\n",
-       "  AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_xuNXwm2P6U2Pp2pAbC1sdIBz', 'function': {'arguments': '{\"x\": 3, \"y\": 5}', 'name': 'add'}, 'type': 'function'}, {'id': 'call_0pImUJUDlYa5zfBcxxuvWyYS', 'function': {'arguments': '{\"x\": 8, \"y\": 2.743}', 'name': 'exponentiate'}, 'type': 'function'}, {'id': 'call_yaownQ9TZK0dkqD1KSFyax4H', 'function': {'arguments': '{\"x\": 17.24, \"y\": -918.1241}', 'name': 'add'}, 'type': 'function'}], 'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 75, 'prompt_tokens': 131, 'total_tokens': 206, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': None, 'id': 'chatcmpl-ByJm2qxSWU3oTTSZQv64J4XQKZhA6', 'service_tier': 'default', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run--35fad027-47f7-44d3-aa8b-99f4fc24098c-0', tool_calls=[{'name': 'add', 'args': {'x': 3, 'y': 5}, 'id': 'call_xuNXwm2P6U2Pp2pAbC1sdIBz', 'type': 'tool_call'}, {'name': 'exponentiate', 'args': {'x': 8, 'y': 2.743}, 'id': 'call_0pImUJUDlYa5zfBcxxuvWyYS', 'type': 'tool_call'}, {'name': 'add', 'args': {'x': 17.24, 'y': -918.1241}, 'id': 'call_yaownQ9TZK0dkqD1KSFyax4H', 'type': 'tool_call'}], usage_metadata={'input_tokens': 131, 'output_tokens': 75, 'total_tokens': 206, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 0}}),\n",
-       "  ToolMessage(content='8.0', tool_call_id='call_xuNXwm2P6U2Pp2pAbC1sdIBz'),\n",
-       "  ToolMessage(content='300.03770462067547', tool_call_id='call_0pImUJUDlYa5zfBcxxuvWyYS'),\n",
-       "  ToolMessage(content='-900.8841', tool_call_id='call_yaownQ9TZK0dkqD1KSFyax4H'),\n",
-       "  AIMessage(content='The results are:\\n1. 3 plus 5 is 8.\\n2. 5 raised to the power of 2.743 is approximately 300.04.\\n3. 17.24 minus 918.1241 is approximately -900.88.', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 55, 'prompt_tokens': 236, 'total_tokens': 291, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': None, 'id': 'chatcmpl-ByJm345MYnpowGS90iAZAlSs7haed', 'service_tier': 'default', 'finish_reason': 'stop', 'logprobs': None}, id='run--5fa66d47-d80e-45d0-9c32-31348c735d72-0', usage_metadata={'input_tokens': 236, 'output_tokens': 55, 'total_tokens': 291, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 0}})]}"
+       "{'messages': [HumanMessage(content=\"what's 3 plus 5 raised to the 2.743. also what's 17.24 - 918.1241\"),\n",
+       "  AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_6yMU2WsS4Bqgi1WxFHxtfJRc', 'function': {'arguments': '{\"x\": 8, \"y\": 2.743}', 'name': 'exponentiate'}, 'type': 'function'}, {'id': 'call_GAL3dQiKFF9XEV0RrRLPTvVp', 'function': {'arguments': '{\"x\": 17.24, \"y\": -918.1241}', 'name': 'add'}, 'type': 'function'}]}, response_metadata={'token_usage': {'completion_tokens': 58, 'prompt_tokens': 168, 'total_tokens': 226}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-528302fc-7acf-4c11-82c4-119ccf40c573-0', tool_calls=[{'name': 'exponentiate', 'args': {'x': 8, 'y': 2.743}, 'id': 'call_6yMU2WsS4Bqgi1WxFHxtfJRc'}, {'name': 'add', 'args': {'x': 17.24, 'y': -918.1241}, 'id': 'call_GAL3dQiKFF9XEV0RrRLPTvVp'}]),\n",
+       "  ToolMessage(content='300.03770462067547', tool_call_id='call_6yMU2WsS4Bqgi1WxFHxtfJRc'),\n",
+       "  ToolMessage(content='-900.8841', tool_call_id='call_GAL3dQiKFF9XEV0RrRLPTvVp'),\n",
+       "  AIMessage(content='The result of \\\\(3 + 5^{2.743}\\\\) is approximately 300.04, and the result of \\\\(17.24 - 918.1241\\\\) is approximately -900.88.', response_metadata={'token_usage': {'completion_tokens': 44, 'prompt_tokens': 251, 'total_tokens': 295}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'stop', 'logprobs': None}, id='run-d1161669-ed09-4b18-94bd-6d8530df5aa8-0')]}"
       ]
      },
-     "execution_count": 3,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -147,17 +146,17 @@
     {
      "data": {
       "text/plain": [
-       "{'messages': [HumanMessage(content=\"what's 3 plus 5 raised to the 2.743. also what's 17.24 - 918.1241\", additional_kwargs={}, response_metadata={}),\n",
-       "  AIMessage(content=[{'text': \"I'll solve these calculations for you.\\n\\nFor the first part, I need to calculate 3 plus 5 raised to the power of 2.743.\\n\\nLet me break this down:\\n1) First, I'll calculate 5 raised to the power of 2.743\\n2) Then add 3 to the result\", 'type': 'text'}, {'id': 'toolu_01L1mXysBQtpPLQ2AZTaCGmE', 'input': {'x': 5, 'y': 2.743}, 'name': 'exponentiate', 'type': 'tool_use'}], additional_kwargs={}, response_metadata={'id': 'msg_01HCbDmuzdg9ATMyKbnecbEE', 'model': 'claude-3-7-sonnet-20250219', 'stop_reason': 'tool_use', 'stop_sequence': None, 'usage': {'cache_creation_input_tokens': 0, 'cache_read_input_tokens': 0, 'input_tokens': 563, 'output_tokens': 146, 'server_tool_use': None, 'service_tier': 'standard'}, 'model_name': 'claude-3-7-sonnet-20250219'}, id='run--9f6469fb-bcbb-4c1c-9eec-79f6979c38e6-0', tool_calls=[{'name': 'exponentiate', 'args': {'x': 5, 'y': 2.743}, 'id': 'toolu_01L1mXysBQtpPLQ2AZTaCGmE', 'type': 'tool_call'}], usage_metadata={'input_tokens': 563, 'output_tokens': 146, 'total_tokens': 709, 'input_token_details': {'cache_read': 0, 'cache_creation': 0}}),\n",
-       "  ToolMessage(content='82.65606421491815', tool_call_id='toolu_01L1mXysBQtpPLQ2AZTaCGmE'),\n",
-       "  AIMessage(content=[{'text': \"Now I'll add 3 to this result:\", 'type': 'text'}, {'id': 'toolu_01NARC83e9obV35mZ6jYzBiN', 'input': {'x': 3, 'y': 82.65606421491815}, 'name': 'add', 'type': 'tool_use'}], additional_kwargs={}, response_metadata={'id': 'msg_01ELwyCtVLeGC685PUFqmdz2', 'model': 'claude-3-7-sonnet-20250219', 'stop_reason': 'tool_use', 'stop_sequence': None, 'usage': {'cache_creation_input_tokens': 0, 'cache_read_input_tokens': 0, 'input_tokens': 727, 'output_tokens': 87, 'server_tool_use': None, 'service_tier': 'standard'}, 'model_name': 'claude-3-7-sonnet-20250219'}, id='run--d5af3d7c-e8b7-4cc2-997a-ad2dafd08751-0', tool_calls=[{'name': 'add', 'args': {'x': 3, 'y': 82.65606421491815}, 'id': 'toolu_01NARC83e9obV35mZ6jYzBiN', 'type': 'tool_call'}], usage_metadata={'input_tokens': 727, 'output_tokens': 87, 'total_tokens': 814, 'input_token_details': {'cache_read': 0, 'cache_creation': 0}}),\n",
-       "  ToolMessage(content='85.65606421491815', tool_call_id='toolu_01NARC83e9obV35mZ6jYzBiN'),\n",
-       "  AIMessage(content=[{'text': \"For the second part, you asked for 17.24 - 918.1241. I don't have a subtraction function available, but I can rewrite this as adding a negative number: 17.24 + (-918.1241)\", 'type': 'text'}, {'id': 'toolu_01Q6fLcZkBWZpMPCZ55WXR3N', 'input': {'x': 17.24, 'y': -918.1241}, 'name': 'add', 'type': 'tool_use'}], additional_kwargs={}, response_metadata={'id': 'msg_01WkmDwUxWjjaKGnTtdLGJnN', 'model': 'claude-3-7-sonnet-20250219', 'stop_reason': 'tool_use', 'stop_sequence': None, 'usage': {'cache_creation_input_tokens': 0, 'cache_read_input_tokens': 0, 'input_tokens': 832, 'output_tokens': 130, 'server_tool_use': None, 'service_tier': 'standard'}, 'model_name': 'claude-3-7-sonnet-20250219'}, id='run--39a6fbda-4c81-47a6-b361-524bd4ee5823-0', tool_calls=[{'name': 'add', 'args': {'x': 17.24, 'y': -918.1241}, 'id': 'toolu_01Q6fLcZkBWZpMPCZ55WXR3N', 'type': 'tool_call'}], usage_metadata={'input_tokens': 832, 'output_tokens': 130, 'total_tokens': 962, 'input_token_details': {'cache_read': 0, 'cache_creation': 0}}),\n",
-       "  ToolMessage(content='-900.8841', tool_call_id='toolu_01Q6fLcZkBWZpMPCZ55WXR3N'),\n",
-       "  AIMessage(content='So, the answers are:\\n1) 3 plus 5 raised to the 2.743 = 85.65606421491815\\n2) 17.24 - 918.1241 = -900.8841', additional_kwargs={}, response_metadata={'id': 'msg_015Yoc62CvdJbANGFouiQ6AQ', 'model': 'claude-3-7-sonnet-20250219', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'cache_creation_input_tokens': 0, 'cache_read_input_tokens': 0, 'input_tokens': 978, 'output_tokens': 58, 'server_tool_use': None, 'service_tier': 'standard'}, 'model_name': 'claude-3-7-sonnet-20250219'}, id='run--174c0882-6180-47ea-8f63-d7b747302327-0', usage_metadata={'input_tokens': 978, 'output_tokens': 58, 'total_tokens': 1036, 'input_token_details': {'cache_read': 0, 'cache_creation': 0}})]}"
+       "{'messages': [HumanMessage(content=\"what's 3 plus 5 raised to the 2.743. also what's 17.24 - 918.1241\"),\n",
+       "  AIMessage(content=[{'text': \"Okay, let's break this down into two parts:\", 'type': 'text'}, {'id': 'toolu_01DEhqcXkXTtzJAiZ7uMBeDC', 'input': {'x': 3, 'y': 5}, 'name': 'add', 'type': 'tool_use'}], response_metadata={'id': 'msg_01AkLGH8sxMHaH15yewmjwkF', 'model': 'claude-3-sonnet-20240229', 'stop_reason': 'tool_use', 'stop_sequence': None, 'usage': {'input_tokens': 450, 'output_tokens': 81}}, id='run-f35bfae8-8ded-4f8a-831b-0940d6ad16b6-0', tool_calls=[{'name': 'add', 'args': {'x': 3, 'y': 5}, 'id': 'toolu_01DEhqcXkXTtzJAiZ7uMBeDC'}]),\n",
+       "  ToolMessage(content='8.0', tool_call_id='toolu_01DEhqcXkXTtzJAiZ7uMBeDC'),\n",
+       "  AIMessage(content=[{'id': 'toolu_013DyMLrvnrto33peAKMGMr1', 'input': {'x': 8.0, 'y': 2.743}, 'name': 'exponentiate', 'type': 'tool_use'}], response_metadata={'id': 'msg_015Fmp8aztwYcce2JDAFfce3', 'model': 'claude-3-sonnet-20240229', 'stop_reason': 'tool_use', 'stop_sequence': None, 'usage': {'input_tokens': 545, 'output_tokens': 75}}, id='run-48aaeeeb-a1e5-48fd-a57a-6c3da2907b47-0', tool_calls=[{'name': 'exponentiate', 'args': {'x': 8.0, 'y': 2.743}, 'id': 'toolu_013DyMLrvnrto33peAKMGMr1'}]),\n",
+       "  ToolMessage(content='300.03770462067547', tool_call_id='toolu_013DyMLrvnrto33peAKMGMr1'),\n",
+       "  AIMessage(content=[{'text': 'So 3 plus 5 raised to the 2.743 power is 300.04.\\n\\nFor the second part:', 'type': 'text'}, {'id': 'toolu_01UTmMrGTmLpPrPCF1rShN46', 'input': {'x': 17.24, 'y': -918.1241}, 'name': 'add', 'type': 'tool_use'}], response_metadata={'id': 'msg_015TkhfRBENPib2RWAxkieH6', 'model': 'claude-3-sonnet-20240229', 'stop_reason': 'tool_use', 'stop_sequence': None, 'usage': {'input_tokens': 638, 'output_tokens': 105}}, id='run-45fb62e3-d102-4159-881d-241c5dbadeed-0', tool_calls=[{'name': 'add', 'args': {'x': 17.24, 'y': -918.1241}, 'id': 'toolu_01UTmMrGTmLpPrPCF1rShN46'}]),\n",
+       "  ToolMessage(content='-900.8841', tool_call_id='toolu_01UTmMrGTmLpPrPCF1rShN46'),\n",
+       "  AIMessage(content='Therefore, 17.24 - 918.1241 = -900.8841', response_metadata={'id': 'msg_01LgKnRuUcSyADCpxv9tPoYD', 'model': 'claude-3-sonnet-20240229', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'input_tokens': 759, 'output_tokens': 24}}, id='run-1008254e-ccd1-497c-8312-9550dd77bd08-0')]}"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -178,7 +177,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "langchain",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -192,7 +191,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.16"
+   "version": "3.10.4"
   }
  },
  "nbformat": 4,

docs/Makefile

@@ -1,9 +1,9 @@
-# We build the docs in these stages:
-# 1. Install vercel and python dependencies
-# 2. Copy files from "source dir" to "intermediate dir"
-# 2. Generate files like model feat table, etc in "intermediate dir"
-# 3. Copy files to their right spots (e.g. langserve readme) in "intermediate dir"
-# 4. Build the docs from "intermediate dir" to "output dir"
+# we build the docs in these stages:
+# 1. install vercel and python dependencies
+# 2. copy files from "source dir" to "intermediate dir"
+# 2. generate files like model feat table, etc in "intermediate dir"
+# 3. copy files to their right spots (e.g. langserve readme) in "intermediate dir"
+# 4. build the docs from "intermediate dir" to "output dir"
 
 SOURCE_DIR = docs/
 INTERMEDIATE_DIR = build/intermediate/docs
@@ -18,45 +18,32 @@ PORT ?= 3001
 clean:
 	rm -rf build
 
-clean-cache:
-	rm -rf build .venv/deps_installed
-
 install-vercel-deps:
 	yum -y -q update
 	yum -y -q install gcc bzip2-devel libffi-devel zlib-devel wget tar gzip rsync -y
 
 install-py-deps:
-	@echo "📦 Installing Python dependencies..."
-	@if [ ! -d .venv ]; then python3 -m venv .venv; fi
-	@if [ ! -f .venv/deps_installed ]; then \
-		$(PYTHON) -m pip install -q --upgrade pip --disable-pip-version-check; \
-		$(PYTHON) -m pip install -q --upgrade uv; \
-		$(PYTHON) -m uv pip install -q --pre -r vercel_requirements.txt; \
-		$(PYTHON) -m uv pip install -q --pre $$($(PYTHON) scripts/partner_deps_list.py) --overrides vercel_overrides.txt; \
-		touch .venv/deps_installed; \
-	fi
-	@echo "✅ Dependencies installed"
+	python3 -m venv .venv
+	$(PYTHON) -m pip install -q --upgrade pip
+	$(PYTHON) -m pip install -q --upgrade uv
+	$(PYTHON) -m uv pip install -q --pre -r vercel_requirements.txt
+	$(PYTHON) -m uv pip install -q --pre $$($(PYTHON) scripts/partner_deps_list.py) --overrides vercel_overrides.txt
 
 generate-files:
-	@echo "📄 Generating documentation files..."
 	mkdir -p $(INTERMEDIATE_DIR)
 	cp -rp $(SOURCE_DIR)/* $(INTERMEDIATE_DIR)
-	@if [ ! -f build/langserve_readme_cache.md ] || [ $$(find build/langserve_readme_cache.md -mtime +1 -print) ]; then \
-		echo "🌐 Downloading LangServe README..."; \
-		curl -s https://raw.githubusercontent.com/langchain-ai/langserve/main/README.md | sed 's/<=/\&lt;=/g' > build/langserve_readme_cache.md; \
-	fi
-	cp build/langserve_readme_cache.md $(INTERMEDIATE_DIR)/langserve.md
+
+	$(PYTHON) scripts/tool_feat_table.py $(INTERMEDIATE_DIR)
+
+	$(PYTHON) scripts/kv_store_feat_table.py $(INTERMEDIATE_DIR)
+
+	$(PYTHON) scripts/partner_pkg_table.py $(INTERMEDIATE_DIR)
+
+	curl https://raw.githubusercontent.com/langchain-ai/langserve/main/README.md | sed 's/<=/\&lt;=/g' > $(INTERMEDIATE_DIR)/langserve.md
 	cp ../SECURITY.md $(INTERMEDIATE_DIR)/security.md
-	@echo "🔧 Generating feature tables and processing links..."
-	$(PYTHON) scripts/tool_feat_table.py $(INTERMEDIATE_DIR) & \
-	$(PYTHON) scripts/kv_store_feat_table.py $(INTERMEDIATE_DIR) & \
-	$(PYTHON) scripts/partner_pkg_table.py $(INTERMEDIATE_DIR) & \
-	$(PYTHON) scripts/resolve_local_links.py $(INTERMEDIATE_DIR)/langserve.md https://github.com/langchain-ai/langserve/tree/main/ & \
-	wait
-	@echo "✅ Files generated"
+	$(PYTHON) scripts/resolve_local_links.py $(INTERMEDIATE_DIR)/langserve.md https://github.com/langchain-ai/langserve/tree/main/
 
 copy-infra:
-	@echo "📂 Copying infrastructure files..."
 	mkdir -p $(OUTPUT_NEW_DIR)
 	cp -r src $(OUTPUT_NEW_DIR)
 	cp vercel.json $(OUTPUT_NEW_DIR)
@@ -68,22 +55,15 @@ copy-infra:
 	cp -r static $(OUTPUT_NEW_DIR)
 	cp -r ../libs/cli/langchain_cli/integration_template $(OUTPUT_NEW_DIR)/src/theme
 	cp yarn.lock $(OUTPUT_NEW_DIR)
-	@echo "✅ Infrastructure files copied"
 
 render:
-	@echo "📓 Converting notebooks (this may take a while)..."
 	$(PYTHON) scripts/notebook_convert.py $(INTERMEDIATE_DIR) $(OUTPUT_NEW_DOCS_DIR)
-	@echo "✅ Notebooks converted"
 
 md-sync:
-	@echo "📝 Syncing markdown files..."
 	rsync -avmq --include="*/" --include="*.mdx" --include="*.md" --include="*.png" --include="*/_category_.yml" --exclude="*" $(INTERMEDIATE_DIR)/ $(OUTPUT_NEW_DOCS_DIR)
-	@echo "✅ Markdown files synced"
 
 append-related:
-	@echo "🔗 Appending related links..."
 	$(PYTHON) scripts/append_related_links.py $(OUTPUT_NEW_DOCS_DIR)
-	@echo "✅ Related links appended"
 
 generate-references:
 	$(PYTHON) scripts/generate_api_reference_links.py --docs_dir $(OUTPUT_NEW_DOCS_DIR)
@@ -91,10 +71,6 @@ generate-references:
 update-md: generate-files md-sync
 
 build: install-py-deps generate-files copy-infra render md-sync append-related
-	@echo ""
-	@echo "🎉 Documentation build complete!"
-	@echo "📖 To view locally, run: cd docs && make start"
-	@echo ""
 
 vercel-build: install-vercel-deps build generate-references
 	rm -rf docs
@@ -108,9 +84,4 @@ vercel-build: install-vercel-deps build generate-references
 	NODE_OPTIONS="--max-old-space-size=5000" yarn run docusaurus build
 
 start:
-	@echo "🚀 Starting documentation server on port $(PORT)..."
-	@echo "📖 Installing Node.js dependencies..."
-	cd $(OUTPUT_NEW_DIR) && yarn install --silent
-	@echo "🌐 Starting server at http://localhost:$(PORT)"
-	@echo "Press Ctrl+C to stop the server"
-	cd $(OUTPUT_NEW_DIR) && yarn start --port=$(PORT)
+	cd $(OUTPUT_NEW_DIR) && yarn && yarn start --port=$(PORT)

docs/api_reference/conf.py

@@ -97,7 +97,7 @@ def skip_private_members(app, what, name, obj, skip, options):
     if hasattr(obj, "__doc__") and obj.__doc__ and ":private:" in obj.__doc__:
         return True
     if name == "__init__" and obj.__objclass__ is object:
-        # don't document default init
+        # dont document default init
         return True
     return None
 
@@ -262,8 +262,6 @@ myst_enable_extensions = ["colon_fence"]
 
 # generate autosummary even if no references
 autosummary_generate = True
-# Don't fail on autosummary import warnings
-autosummary_ignore_module_all = False
 
 html_copy_source = False
 html_show_sourcelink = False

docs/api_reference/create_api_rst.py

@@ -97,7 +97,7 @@ def _load_module_members(module_path: str, namespace: str) -> ModuleMembers:
             if type(type_) is typing_extensions._TypedDictMeta:  # type: ignore
                 kind: ClassKind = "TypedDict"
             elif type(type_) is typing._TypedDictMeta:  # type: ignore
-                kind = "TypedDict"
+                kind: ClassKind = "TypedDict"
             elif (
                 issubclass(type_, Runnable)
                 and issubclass(type_, BaseModel)
@@ -189,7 +189,7 @@ def _load_package_modules(
         if isinstance(package_directory, str)
         else package_directory
     )
-    modules_by_namespace: Dict[str, ModuleMembers] = {}
+    modules_by_namespace = {}
 
     # Get the high level package name
     package_name = package_path.name
@@ -202,12 +202,6 @@ def _load_package_modules(
         if file_path.name.startswith("_"):
             continue
 
-        if "integration_template" in file_path.parts:
-            continue
-
-        if "project_template" in file_path.parts:
-            continue
-
         relative_module_name = file_path.relative_to(package_path)
 
         # Skip if any module part starts with an underscore
@@ -283,7 +277,7 @@ def _construct_doc(
 .. toctree::
     :hidden:
     :maxdepth: 2
-
+    
 """
     index_autosummary = """
 """
@@ -365,9 +359,9 @@ def _construct_doc(
 
                 module_doc += f"""\
     :template: {template}
-
+    
     {class_["qualified_name"]}
-
+    
 """
                 index_autosummary += f"""
     {class_["qualified_name"]}
@@ -501,7 +495,15 @@ def _package_namespace(package_name: str) -> str:
 
 def _package_dir(package_name: str = "langchain") -> Path:
     """Return the path to the directory containing the documentation."""
-    if (ROOT_DIR / "libs" / package_name).exists():
+    if package_name in (
+        "langchain",
+        "experimental",
+        "community",
+        "core",
+        "cli",
+        "text-splitters",
+        "standard-tests",
+    ):
         return ROOT_DIR / "libs" / package_name / _package_namespace(package_name)
     else:
         return (
@@ -545,20 +547,13 @@ def _build_index(dirs: List[str]) -> None:
         "ai21": "AI21",
         "ibm": "IBM",
     }
-    ordered = [
-        "core",
-        "langchain",
-        "text-splitters",
-        "community",
-        "experimental",
-        "standard-tests",
-    ]
+    ordered = ["core", "langchain", "text-splitters", "community", "experimental"]
     main_ = [dir_ for dir_ in ordered if dir_ in dirs]
     integrations = sorted(dir_ for dir_ in dirs if dir_ not in main_)
     doc = """# LangChain Python API Reference
 
-Welcome to the LangChain Python API reference. This is a reference for all
-`langchain-x` packages.
+Welcome to the LangChain Python API reference. This is a reference for all 
+`langchain-x` packages. 
 
 For user guides see [https://python.langchain.com](https://python.langchain.com).
 
@@ -597,12 +592,7 @@ For the legacy API reference hosted on ReadTheDocs see [https://api.python.langc
     if integrations:
         integration_headers = [
             " ".join(
-                custom_names.get(
-                    x,
-                    x.title().replace("db", "DB")
-                    if dir_ == "langchain_v1"
-                    else x.title().replace("ai", "AI").replace("db", "DB"),
-                )
+                custom_names.get(x, x.title().replace("ai", "AI").replace("db", "DB"))
                 for x in dir_.split("-")
             )
             for dir_ in integrations
@@ -670,12 +660,18 @@ def main(dirs: Optional[list] = None) -> None:
     print("Starting to build API reference files.")
     if not dirs:
         dirs = [
-            p.parent.name
-            for p in (ROOT_DIR / "libs").rglob("pyproject.toml")
-            # Exclude packages that are not directly under libs/ or libs/partners/
-            if p.parent.parent.name in ("libs", "partners")
+            dir_
+            for dir_ in os.listdir(ROOT_DIR / "libs")
+            if dir_ not in ("cli", "partners", "packages.yml")
+            and "pyproject.toml" in os.listdir(ROOT_DIR / "libs" / dir_)
         ]
-    for dir_ in sorted(dirs):
+        dirs += [
+            dir_
+            for dir_ in os.listdir(ROOT_DIR / "libs" / "partners")
+            if os.path.isdir(ROOT_DIR / "libs" / "partners" / dir_)
+            and "pyproject.toml" in os.listdir(ROOT_DIR / "libs" / "partners" / dir_)
+        ]
+    for dir_ in dirs:
         # Skip any hidden directories
         # Some of these could be present by mistake in the code base
         # e.g., .pytest_cache from running tests from the wrong location.
@@ -686,7 +682,7 @@ def main(dirs: Optional[list] = None) -> None:
             print("Building package:", dir_)
             _build_rst_file(package_name=dir_)
 
-    _build_index(sorted(dirs))
+    _build_index(dirs)
     print("API reference files built.")
 
 

docs/docs/additional_resources/arxiv_references.mdx

@@ -1,10 +1,10 @@
 # arXiv
-
+            
 LangChain implements the latest research in the field of Natural Language Processing.
 This page contains `arXiv` papers referenced in the LangChain Documentation, API Reference,
  Templates, and Cookbooks.
 
-From the opposite direction, scientists use `LangChain` in research and reference it in the research papers.
+From the opposite direction, scientists use `LangChain` in research and reference it in the research papers. 
 
 `arXiv` papers with references to:
  [LangChain](https://arxiv.org/search/?query=langchain&searchtype=all&source=header) | [LangGraph](https://arxiv.org/search/?query=langgraph&searchtype=all&source=header) | [LangSmith](https://arxiv.org/search/?query=langsmith&searchtype=all&source=header)
@@ -83,7 +83,7 @@ a set of open-domain QA datasets, covering multiple query complexities, and
 show that ours enhances the overall efficiency and accuracy of QA systems,
 compared to relevant baselines including the adaptive retrieval approaches.
 Code is available at: https://github.com/starsuzi/Adaptive-RAG.
-
+                
 ## Self-Discover: Large Language Models Self-Compose Reasoning Structures
 
 - **Authors:** Pei Zhou, Jay Pujara, Xiang Ren,  et al.
@@ -106,7 +106,7 @@ than 20%, while requiring 10-40x fewer inference compute. Finally, we show that
 the self-discovered reasoning structures are universally applicable across
 model families: from PaLM 2-L to GPT-4, and from GPT-4 to Llama2, and share
 commonalities with human reasoning patterns.
-
+                
 ## RAG-Fusion: a New Take on Retrieval-Augmented Generation
 
 - **Authors:** Zackary Rackauckas
@@ -129,7 +129,7 @@ the generated queries' relevance to the original query is insufficient. This
 research marks significant progress in artificial intelligence (AI) and natural
 language processing (NLP) applications and demonstrates transformations in a
 global and multi-industry context.
-
+                
 ## RAPTOR: Recursive Abstractive Processing for Tree-Organized Retrieval
 
 - **Authors:** Parth Sarthi, Salman Abdullah, Aditi Tuli,  et al.
@@ -152,7 +152,7 @@ tasks. On question-answering tasks that involve complex, multi-step reasoning,
 we show state-of-the-art results; for example, by coupling RAPTOR retrieval
 with the use of GPT-4, we can improve the best performance on the QuALITY
 benchmark by 20% in absolute accuracy.
-
+                
 ## Corrective Retrieval Augmented Generation
 
 - **Authors:** Shi-Qi Yan, Jia-Chen Gu, Yun Zhu,  et al.
@@ -180,7 +180,7 @@ them. CRAG is plug-and-play and can be seamlessly coupled with various
 RAG-based approaches. Experiments on four datasets covering short- and
 long-form generation tasks show that CRAG can significantly improve the
 performance of RAG-based approaches.
-
+                
 ## Code Generation with AlphaCodium: From Prompt Engineering to Flow Engineering
 
 - **Authors:** Tal Ridnik, Dedy Kredo, Itamar Friedman
@@ -206,7 +206,7 @@ to 44% with the AlphaCodium flow. Many of the principles and best practices
 acquired in this work, we believe, are broadly applicable to general code
 generation tasks. Full implementation is available at:
 https://github.com/Codium-ai/AlphaCodium
-
+                
 ## Mixtral of Experts
 
 - **Authors:** Albert Q. Jiang, Alexandre Sablayrolles, Antoine Roux,  et al.
@@ -229,7 +229,7 @@ multilingual benchmarks. We also provide a model fine-tuned to follow
 instructions, Mixtral 8x7B - Instruct, that surpasses GPT-3.5 Turbo,
 Claude-2.1, Gemini Pro, and Llama 2 70B - chat model on human benchmarks. Both
 the base and instruct models are released under the Apache 2.0 license.
-
+                
 ## Dense X Retrieval: What Retrieval Granularity Should We Use?
 
 - **Authors:** Tong Chen, Hongwei Wang, Sihao Chen,  et al.
@@ -255,7 +255,7 @@ also enhances the performance of downstream QA tasks, since the retrieved texts
 are more condensed with question-relevant information, reducing the need for
 lengthy input tokens and minimizing the inclusion of extraneous, irrelevant
 information.
-
+                
 ## Chain-of-Note: Enhancing Robustness in Retrieval-Augmented Language Models
 
 - **Authors:** Wenhao Yu, Hongming Zhang, Xiaoman Pan,  et al.
@@ -286,7 +286,7 @@ with CoN significantly outperform standard RALMs. Notably, CoN achieves an
 average improvement of +7.9 in EM score given entirely noisy retrieved
 documents and +10.5 in rejection rates for real-time questions that fall
 outside the pre-training knowledge scope.
-
+                
 ## Self-RAG: Learning to Retrieve, Generate, and Critique through Self-Reflection
 
 - **Authors:** Akari Asai, Zeqiu Wu, Yizhong Wang,  et al.
@@ -317,7 +317,7 @@ outperforms ChatGPT and retrieval-augmented Llama2-chat on Open-domain QA,
 reasoning and fact verification tasks, and it shows significant gains in
 improving factuality and citation accuracy for long-form generations relative
 to these models.
-
+                
 ## Take a Step Back: Evoking Reasoning via Abstraction in Large Language Models
 
 - **Authors:** Huaixiu Steven Zheng, Swaroop Mishra, Xinyun Chen,  et al.
@@ -338,7 +338,7 @@ substantial performance gains on various challenging reasoning-intensive tasks
 including STEM, Knowledge QA, and Multi-Hop Reasoning. For instance, Step-Back
 Prompting improves PaLM-2L performance on MMLU (Physics and Chemistry) by 7%
 and 11% respectively, TimeQA by 27%, and MuSiQue by 7%.
-
+                
 ## Skeleton-of-Thought: Prompting LLMs for Efficient Parallel Generation
 
 - **Authors:** Xuefei Ning, Zinan Lin, Zixuan Zhou,  et al.
@@ -359,7 +359,7 @@ potentially improve the answer quality on several question categories. SoT is
 an initial attempt at data-centric optimization for inference efficiency, and
 showcases the potential of eliciting high-quality answers by explicitly
 planning the answer structure in language.
-
+                
 ## Llama 2: Open Foundation and Fine-Tuned Chat Models
 
 - **Authors:** Hugo Touvron, Louis Martin, Kevin Stone,  et al.
@@ -377,7 +377,7 @@ safety, may be a suitable substitute for closed-source models. We provide a
 detailed description of our approach to fine-tuning and safety improvements of
 Llama 2-Chat in order to enable the community to build on our work and
 contribute to the responsible development of LLMs.
-
+                
 ## Lost in the Middle: How Language Models Use Long Contexts
 
 - **Authors:** Nelson F. Liu, Kevin Lin, John Hewitt,  et al.
@@ -399,7 +399,7 @@ significantly degrades when models must access relevant information in the
 middle of long contexts, even for explicitly long-context models. Our analysis
 provides a better understanding of how language models use their input context
 and provides new evaluation protocols for future long-context language models.
-
+                
 ## Query Rewriting for Retrieval-Augmented Large Language Models
 
 - **Authors:** Xinbei Ma, Yeyun Gong, Pengcheng He,  et al.
@@ -426,7 +426,7 @@ Evaluation is conducted on downstream tasks, open-domain QA and multiple-choice
 QA. Experiments results show consistent performance improvement, indicating
 that our framework is proven effective and scalable, and brings a new framework
 for retrieval-augmented LLM.
-
+                
 ## Large Language Model Guided Tree-of-Thought
 
 - **Authors:** Jieyi Long
@@ -452,7 +452,7 @@ the effectiveness of the proposed technique, we implemented a ToT-based solver
 for the Sudoku Puzzle. Experimental results show that the ToT framework can
 significantly increase the success rate of Sudoku puzzle solving. Our
 implementation of the ToT-based Sudoku solver is available on [GitHub](https://github.com/jieyilong/tree-of-thought-puzzle-solver).
-
+                
 ## Plan-and-Solve Prompting: Improving Zero-Shot Chain-of-Thought Reasoning by Large Language Models
 
 - **Authors:** Lei Wang, Wanyu Xu, Yihuai Lan,  et al.
@@ -482,7 +482,7 @@ by a large margin, is comparable to or exceeds Zero-shot-Program-of-Thought
 Prompting, and has comparable performance with 8-shot CoT prompting on the math
 reasoning problem. The code can be found at
 https://github.com/AGI-Edgerunners/Plan-and-Solve-Prompting.
-
+                
 ## Zero-Shot Listwise Document Reranking with a Large Language Model
 
 - **Authors:** Xueguang Ma, Xinyu Zhang, Ronak Pradeep,  et al.
@@ -506,7 +506,7 @@ results, but can also act as a final-stage reranker to improve the top-ranked
 results of a pointwise method for improved efficiency. Additionally, we apply
 our approach to subsets of MIRACL, a recent multilingual retrieval dataset,
 with results showing its potential to generalize across different languages.
-
+                
 ## Visual Instruction Tuning
 
 - **Authors:** Haotian Liu, Chunyuan Li, Qingyang Wu,  et al.
@@ -530,7 +530,7 @@ instruction-following dataset. When fine-tuned on Science QA, the synergy of
 LLaVA and GPT-4 achieves a new state-of-the-art accuracy of 92.53%. We make
 GPT-4 generated visual instruction tuning data, our model and code base
 publicly available.
-
+                
 ## Generative Agents: Interactive Simulacra of Human Behavior
 
 - **Authors:** Joon Sung Park, Joseph C. O'Brien, Carrie J. Cai,  et al.
@@ -563,7 +563,7 @@ architecture--observation, planning, and reflection--each contribute critically
 to the believability of agent behavior. By fusing large language models with
 computational, interactive agents, this work introduces architectural and
 interaction patterns for enabling believable simulations of human behavior.
-
+                
 ## CAMEL: Communicative Agents for "Mind" Exploration of Large Language Model Society
 
 - **Authors:** Guohao Li, Hasan Abed Al Kader Hammoud, Hani Itani,  et al.
@@ -590,7 +590,7 @@ include introducing a novel communicative agent framework, offering a scalable
 approach for studying the cooperative behaviors and capabilities of multi-agent
 systems, and open-sourcing our library to support research on communicative
 agents and beyond: https://github.com/camel-ai/camel.
-
+                
 ## HuggingGPT: Solving AI Tasks with ChatGPT and its Friends in Hugging Face
 
 - **Authors:** Yongliang Shen, Kaitao Song, Xu Tan,  et al.
@@ -619,7 +619,7 @@ HuggingGPT can tackle a wide range of sophisticated AI tasks spanning different
 modalities and domains and achieve impressive results in language, vision,
 speech, and other challenging tasks, which paves a new way towards the
 realization of artificial general intelligence.
-
+                
 ## A Watermark for Large Language Models
 
 - **Authors:** John Kirchenbauer, Jonas Geiping, Yuxin Wen,  et al.
@@ -641,7 +641,7 @@ interpretable p-values, and derive an information-theoretic framework for
 analyzing the sensitivity of the watermark. We test the watermark using a
 multi-billion parameter model from the Open Pretrained Transformer (OPT)
 family, and discuss robustness and security.
-
+                
 ## Precise Zero-Shot Dense Retrieval without Relevance Labels
 
 - **Authors:** Luyu Gao, Xueguang Ma, Jimmy Lin,  et al.
@@ -670,7 +670,7 @@ details. Our experiments show that HyDE significantly outperforms the
 state-of-the-art unsupervised dense retriever Contriever and shows strong
 performance comparable to fine-tuned retrievers, across various tasks (e.g. web
 search, QA, fact verification) and languages~(e.g. sw, ko, ja).
-
+                
 ## Constitutional AI: Harmlessness from AI Feedback
 
 - **Authors:** Yuntao Bai, Saurav Kadavath, Sandipan Kundu,  et al.
@@ -697,7 +697,7 @@ and RL methods can leverage chain-of-thought style reasoning to improve the
 human-judged performance and transparency of AI decision making. These methods
 make it possible to control AI behavior more precisely and with far fewer human
 labels.
-
+                
 ## Robust and Explainable Identification of Logical Fallacies in Natural Language Arguments
 
 - **Authors:** Zhivar Sourati, Vishnu Priya Prasanna Venkatesh, Darshan Deshpande,  et al.
@@ -727,7 +727,7 @@ components and fallacy classes, indicating that fallacy identification is a
 challenging task that may require specialized forms of reasoning to capture
 various classes. We share our open-source code and data on GitHub to support
 further work on logical fallacy identification.
-
+                
 ## Complementary Explanations for Effective In-Context Learning
 
 - **Authors:** Xi Ye, Srinivasan Iyer, Asli Celikyilmaz,  et al.
@@ -752,7 +752,7 @@ performance. Therefore, we propose a maximal marginal relevance-based exemplar
 selection approach for constructing exemplar sets that are both relevant as
 well as complementary, which successfully improves the in-context learning
 performance across three real-world tasks on multiple LLMs.
-
+                
 ## PAL: Program-aided Language Models
 
 - **Authors:** Luyu Gao, Aman Madaan, Shuyan Zhou,  et al.
@@ -784,7 +784,7 @@ larger models. For example, PAL using Codex achieves state-of-the-art few-shot
 accuracy on the GSM8K benchmark of math word problems, surpassing PaLM-540B
 which uses chain-of-thought by absolute 15% top-1. Our code and data are
 publicly available at http://reasonwithpal.com/ .
-
+                
 ## An Analysis of Fusion Functions for Hybrid Retrieval
 
 - **Authors:** Sebastian Bruch, Siyu Gai, Amir Ingber
@@ -803,7 +803,7 @@ learning of a CC fusion is generally agnostic to the choice of score
 normalization; that CC outperforms RRF in in-domain and out-of-domain settings;
 and finally, that CC is sample efficient, requiring only a small set of
 training examples to tune its only parameter to a target domain.
-
+                
 ## ReAct: Synergizing Reasoning and Acting in Language Models
 
 - **Authors:** Shunyu Yao, Jeffrey Zhao, Dian Yu,  et al.
@@ -835,7 +835,7 @@ benchmarks (ALFWorld and WebShop), ReAct outperforms imitation and
 reinforcement learning methods by an absolute success rate of 34% and 10%
 respectively, while being prompted with only one or two in-context examples.
 Project site with code: https://react-lm.github.io
-
+                
 ## Deep Lake: a Lakehouse for Deep Learning
 
 - **Authors:** Sasun Hambardzumyan, Abhinav Tuli, Levon Ghukasyan,  et al.
@@ -860,7 +860,7 @@ streams the data over the network to (a) Tensor Query Language, (b) in-browser
 visualization engine, or (c) deep learning frameworks without sacrificing GPU
 utilization. Datasets stored in Deep Lake can be accessed from PyTorch,
 TensorFlow, JAX, and integrate with numerous MLOps tools.
-
+                
 ## Matryoshka Representation Learning
 
 - **Authors:** Aditya Kusupati, Gantavya Bhatt, Aniket Rege,  et al.
@@ -891,7 +891,7 @@ representations. Finally, we show that MRL extends seamlessly to web-scale
 datasets (ImageNet, JFT) across various modalities -- vision (ViT, ResNet),
 vision + language (ALIGN) and language (BERT). MRL code and pretrained models
 are open-sourced at https://github.com/RAIVNLab/MRL.
-
+                
 ## Bitext Mining Using Distilled Sentence Representations for Low-Resource Languages
 
 - **Authors:** Kevin Heffernan, Onur Çelebi, Holger Schwenk
@@ -917,7 +917,7 @@ which is valuable in the low-resource setting.
 very low-resource languages and handle 50 African languages, many of which are
 not covered by any other model. For these languages, we train sentence
 encoders, mine bitexts, and validate the bitexts by training NMT systems.
-
+                
 ## Evaluating the Text-to-SQL Capabilities of Large Language Models
 
 - **Authors:** Nitarshan Rajkumar, Raymond Li, Dzmitry Bahdanau
@@ -934,7 +934,7 @@ this setting. Furthermore, we demonstrate on the GeoQuery and Scholar
 benchmarks that a small number of in-domain examples provided in the prompt
 enables Codex to perform better than state-of-the-art models finetuned on such
 few-shot examples.
-
+                
 ## Locally Typical Sampling
 
 - **Authors:** Clara Meister, Tiago Pimentel, Gian Wiher,  et al.
@@ -963,7 +963,7 @@ human evaluations show that, in comparison to nucleus and top-k sampling,
 locally typical sampling offers competitive performance (in both abstractive
 summarization and story generation) in terms of quality while consistently
 reducing degenerate repetitions.
-
+                
 ## ColBERTv2: Effective and Efficient Retrieval via Lightweight Late Interaction
 
 - **Authors:** Keshav Santhanam, Omar Khattab, Jon Saad-Falcon,  et al.
@@ -985,7 +985,7 @@ improve the quality and space footprint of late interaction. We evaluate
 ColBERTv2 across a wide range of benchmarks, establishing state-of-the-art
 quality within and outside the training domain while reducing the space
 footprint of late interaction models by 6--10$\times$.
-
+                
 ## Learning Transferable Visual Models From Natural Language Supervision
 
 - **Authors:** Alec Radford, Jong Wook Kim, Chris Hallacy,  et al.
@@ -1014,7 +1014,7 @@ For instance, we match the accuracy of the original ResNet-50 on ImageNet
 zero-shot without needing to use any of the 1.28 million training examples it
 was trained on. We release our code and pre-trained model weights at
 https://github.com/OpenAI/CLIP.
-
+                
 ## Language Models are Few-Shot Learners
 
 - **Authors:** Tom B. Brown, Benjamin Mann, Nick Ryder,  et al.
@@ -1047,7 +1047,7 @@ training on large web corpora. Finally, we find that GPT-3 can generate samples
 of news articles which human evaluators have difficulty distinguishing from
 articles written by humans. We discuss broader societal impacts of this finding
 and of GPT-3 in general.
-
+                
 ## Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks
 
 - **Authors:** Patrick Lewis, Ethan Perez, Aleksandra Piktus,  et al.
@@ -1078,7 +1078,7 @@ parametric seq2seq models and task-specific retrieve-and-extract architectures.
 For language generation tasks, we find that RAG models generate more specific,
 diverse and factual language than a state-of-the-art parametric-only seq2seq
 baseline.
-
+                
 ## CTRL: A Conditional Transformer Language Model for Controllable Generation
 
 - **Authors:** Nitish Shirish Keskar, Bryan McCann, Lav R. Varshney,  et al.
@@ -1098,3 +1098,4 @@ codes also allow CTRL to predict which parts of the training data are most
 likely given a sequence. This provides a potential method for analyzing large
 amounts of data via model-based source attribution. We have released multiple
 full-sized, pretrained versions of CTRL at https://github.com/salesforce/ctrl.
+                

docs/docs/changes/changelog/core.mdx

@@ -7,4 +7,4 @@
 - `BaseChatModel` methods `__call__`, `call_as_llm`, `predict`, `predict_messages`. Will be removed in 0.2.0. Use `BaseChatModel.invoke` instead.
 - `BaseChatModel` methods `apredict`, `apredict_messages`. Will be removed in 0.2.0. Use `BaseChatModel.ainvoke` instead.
 - `BaseLLM` methods `__call__`, `predict`, `predict_messages`. Will be removed in 0.2.0. Use `BaseLLM.invoke` instead.
-- `BaseLLM` methods `apredict`, `apredict_messages`. Will be removed in 0.2.0. Use `BaseLLM.ainvoke` instead.
+- `BaseLLM` methods `apredict`, `apredict_messages`. Will be removed in 0.2.0. Use `BaseLLM.ainvoke` instead.

docs/docs/changes/changelog/langchain.mdx

@@ -90,4 +90,4 @@ Deprecated classes and methods will be removed in 0.2.0
 | OpenAIMultiFunctionsAgent       | create_openai_tools_agent         | Use LCEL builder over a class                  |
 | SelfAskWithSearchAgent          | create_self_ask_with_search       | Use LCEL builder over a class                  |
 | StructuredChatAgent             | create_structured_chat_agent      | Use LCEL builder over a class                  |
-| XMLAgent                        | create_xml_agent                  | Use LCEL builder over a class                  |
+| XMLAgent                        | create_xml_agent                  | Use LCEL builder over a class                  |

docs/docs/concepts/agents.mdx

@@ -11,8 +11,8 @@ Please see the following resources for more information:
 
 ## Legacy agent concept: AgentExecutor
 
-LangChain previously introduced the `AgentExecutor` as a runtime for agents.
-While it served as an excellent starting point, its limitations became apparent when dealing with more sophisticated and customized agents.
+LangChain previously introduced the `AgentExecutor` as a runtime for agents. 
+While it served as an excellent starting point, its limitations became apparent when dealing with more sophisticated and customized agents. 
 As a result, we're gradually phasing out `AgentExecutor` in favor of more flexible solutions in LangGraph.
 
 ### Transitioning from AgentExecutor to LangGraph

docs/docs/concepts/architecture.mdx

@@ -20,7 +20,8 @@ LangChain is a framework that consists of a number of packages.
 
 This package contains base abstractions for different components and ways to compose them together.
 The interfaces for core components like chat models, vector stores, tools and more are defined here.
-**No third-party integrations are defined here.** The dependencies are kept purposefully very lightweight.
+No third-party integrations are defined here.
+The dependencies are very lightweight.
 
 ## langchain
 

docs/docs/concepts/async.mdx

@@ -1,4 +1,4 @@
-# Async programming with LangChain
+# Async programming with langchain
 
 :::info Prerequisites
 * [Runnable interface](/docs/concepts/runnables)
@@ -12,7 +12,7 @@ You are expected to be familiar with asynchronous programming in Python before r
 This guide specifically focuses on what you need to know to work with LangChain in an asynchronous context, assuming that you are already familiar with asynchronous programming.
 :::
 
-## LangChain asynchronous APIs
+## Langchain asynchronous APIs
 
 Many LangChain APIs are designed to be asynchronous, allowing you to build efficient and responsive applications.
 

docs/docs/concepts/callbacks.mdx

@@ -70,4 +70,4 @@ This is a common reason why you may fail to see events being emitted from custom
 runnables or tools.
 :::
 
-For specifics on how to use callbacks, see the [relevant how-to guides here](/docs/how_to/#callbacks).
+For specifics on how to use callbacks, see the [relevant how-to guides here](/docs/how_to/#callbacks).

docs/docs/concepts/chat_history.mdx

@@ -26,7 +26,7 @@ A full conversation often involves a combination of two patterns of alternating
 
 Since chat models have a maximum limit on input size, it's important to manage chat history and trim it as needed to avoid exceeding the [context window](/docs/concepts/chat_models/#context-window).
 
-While processing chat history, it's essential to preserve a correct conversation structure.
+While processing chat history, it's essential to preserve a correct conversation structure. 
 
 Key guidelines for managing chat history:
 

docs/docs/concepts/chat_models.mdx

@@ -127,7 +127,7 @@ If the input exceeds the context window, the model may not be able to process th
 The size of the input is measured in [tokens](/docs/concepts/tokens) which are the unit of processing that the model uses.
 
 ## Advanced topics
-
+ 
 ### Rate-limiting
 
 Many chat model providers impose a limit on the number of requests that can be made in a given time period.

docs/docs/concepts/embedding_models.mdx

@@ -15,9 +15,9 @@ Embedding models can also be [multimodal](/docs/concepts/multimodality) though s
 
 Imagine being able to capture the essence of any text - a tweet, document, or book - in a single, compact representation.
 This is the power of embedding models, which lie at the heart of many retrieval systems.
-Embedding models transform human language into a format that machines can understand and compare with speed and accuracy.
+Embedding models transform human language into a format that machines can understand and compare with speed and accuracy. 
 These models take text as input and produce a fixed-length array of numbers, a numerical fingerprint of the text's semantic meaning.
-Embeddings allow search system to find relevant documents not just based on keyword matches, but on semantic understanding.
+Embeddings allow search system to find relevant documents not just based on keyword matches, but on semantic understanding. 
 
 ## Key concepts
 
@@ -27,16 +27,16 @@ Embeddings allow search system to find relevant documents not just based on keyw
 
 (2) **Measure similarity**: Embedding vectors can be compared using simple mathematical operations.
 
-## Embedding
+## Embedding 
 
-### Historical context
+### Historical context 
 
-The landscape of embedding models has evolved significantly over the years.
-A pivotal moment came in 2018 when Google introduced [BERT (Bidirectional Encoder Representations from Transformers)](https://www.nvidia.com/en-us/glossary/bert/).
+The landscape of embedding models has evolved significantly over the years. 
+A pivotal moment came in 2018 when Google introduced [BERT (Bidirectional Encoder Representations from Transformers)](https://www.nvidia.com/en-us/glossary/bert/). 
 BERT applied transformer models to embed text as a simple vector representation, which lead to unprecedented performance across various NLP tasks.
-However, BERT wasn't optimized for generating sentence embeddings efficiently.
+However, BERT wasn't optimized for generating sentence embeddings efficiently. 
 This limitation spurred the creation of [SBERT (Sentence-BERT)](https://www.sbert.net/examples/training/sts/README.html), which adapted the BERT architecture to generate semantically rich sentence embeddings, easily comparable via similarity metrics like cosine similarity, dramatically reduced the computational overhead for tasks like finding similar sentences.
-Today, the embedding model ecosystem is diverse, with numerous providers offering their own implementations.
+Today, the embedding model ecosystem is diverse, with numerous providers offering their own implementations. 
 To navigate this variety, researchers and practitioners often turn to benchmarks like the Massive Text Embedding Benchmark (MTEB) [here](https://huggingface.co/blog/mteb) for objective comparisons.
 
 :::info[Further reading]
@@ -93,9 +93,9 @@ LangChain offers many embedding model integrations which you can find [on the em
 
 ## Measure similarity
 
-Each embedding is essentially a set of coordinates, often in a high-dimensional space.
+Each embedding is essentially a set of coordinates, often in a high-dimensional space. 
 In this space, the position of each point (embedding) reflects the meaning of its corresponding text.
-Just as similar words might be close to each other in a thesaurus, similar concepts end up close to each other in this embedding space.
+Just as similar words might be close to each other in a thesaurus, similar concepts end up close to each other in this embedding space. 
 This allows for intuitive comparisons between different pieces of text.
 By reducing text to these numerical representations, we can use simple mathematical operations to quickly measure how alike two pieces of text are, regardless of their original length or structure.
 Some common similarity metrics include:
@@ -118,7 +118,7 @@ def cosine_similarity(vec1, vec2):
 
 similarity = cosine_similarity(query_result, document_result)
 print("Cosine Similarity:", similarity)
-```
+```  
 
 :::info[Further reading]
 
@@ -127,4 +127,4 @@ print("Cosine Similarity:", similarity)
 * See Pinecone's [blog post](https://www.pinecone.io/learn/vector-similarity/) on similarity metrics.
 * See OpenAI's [FAQ](https://platform.openai.com/docs/guides/embeddings/faq) on what similarity metric to use with OpenAI embeddings.
 
-:::
+::: 

docs/docs/concepts/evaluation.mdx

@@ -14,3 +14,4 @@ This process is vital for building reliable applications.
 - It allows you to track results over time and automatically run your evaluators on a schedule or as part of CI/Code
 
 To learn more, check out [this LangSmith guide](https://docs.smith.langchain.com/concepts/evaluation).
+

docs/docs/concepts/example_selectors.mdx

@@ -17,4 +17,4 @@ Sometimes these examples are hardcoded into the prompt, but for more advanced si
 
 ## Related resources
 
-* [Example selector how-to guides](/docs/how_to/#example-selectors)
+* [Example selector how-to guides](/docs/how_to/#example-selectors)

docs/docs/concepts/index.mdx

@@ -31,7 +31,7 @@ The conceptual guide does not cover step-by-step instructions or specific implem
 - **[Vector stores](/docs/concepts/vectorstores)**: Storage of and efficient search over vectors and associated metadata.
 - **[Retriever](/docs/concepts/retrievers)**: A component that returns relevant documents from a knowledge base in response to a query.
 - **[Retrieval Augmented Generation (RAG)](/docs/concepts/rag)**: A technique that enhances language models by combining them with external knowledge bases.
-- **[Agents](/docs/concepts/agents)**: Use a [language model](/docs/concepts/chat_models) to choose a sequence of actions to take. Agents can interact with external resources via [tools](/docs/concepts/tools).
+- **[Agents](/docs/concepts/agents)**: Use a [language model](/docs/concepts/chat_models) to choose a sequence of actions to take. Agents can interact with external resources via [tool](/docs/concepts/tools).
 - **[Prompt templates](/docs/concepts/prompt_templates)**: Component for factoring out the static parts of a model "prompt" (usually a sequence of messages). Useful for serializing, versioning, and reusing these static parts.
 - **[Output parsers](/docs/concepts/output_parsers)**: Responsible for taking the output of a model and transforming it into a more suitable format for downstream tasks. Output parsers were primarily useful prior to the general availability of [tool calling](/docs/concepts/tool_calling) and [structured outputs](/docs/concepts/structured_outputs).
 - **[Few-shot prompting](/docs/concepts/few_shot_prompting)**: A technique for improving model performance by providing a few examples of the task to perform in the prompt.
@@ -48,7 +48,7 @@ The conceptual guide does not cover step-by-step instructions or specific implem
 - **[AIMessage](/docs/concepts/messages#aimessage)**: Represents a complete response from an AI model.
 - **[astream_events](/docs/concepts/chat_models#key-methods)**: Stream granular information from [LCEL](/docs/concepts/lcel) chains.
 - **[BaseTool](/docs/concepts/tools/#tool-interface)**: The base class for all tools in LangChain.
-- **[batch](/docs/concepts/runnables)**: Used to execute a runnable with batch inputs.
+- **[batch](/docs/concepts/runnables)**: Use to execute a runnable with batch inputs.
 - **[bind_tools](/docs/concepts/tool_calling/#tool-binding)**: Allows models to interact with tools.
 - **[Caching](/docs/concepts/chat_models#caching)**: Storing results to avoid redundant calls to a chat model.
 - **[Chat models](/docs/concepts/multimodality/#multimodality-in-chat-models)**: Chat models that handle multiple data modalities.

docs/docs/concepts/messages.mdx

@@ -147,7 +147,7 @@ An `AIMessage` has the following attributes. The attributes which are **standard
 | `tool_calls`         | Standardized     | Tool calls associated with the message. See [tool calling](/docs/concepts/tool_calling) for details.                                                                                                                    |
 | `invalid_tool_calls` | Standardized     | Tool calls with parsing errors associated with the message. See [tool calling](/docs/concepts/tool_calling) for details.                                                                                                |
 | `usage_metadata`     | Standardized     | Usage metadata for a message, such as [token counts](/docs/concepts/tokens). See [Usage Metadata API Reference](https://python.langchain.com/api_reference/core/messages/langchain_core.messages.ai.UsageMetadata.html). |
-| `id`                 | Standardized     | An optional unique identifier for the message, ideally provided by the provider/model that created the message. See [Message IDs](#message-ids) for details.                                                                                                         |
+| `id`                 | Standardized     | An optional unique identifier for the message, ideally provided by the provider/model that created the message.                                                                                                         |
 | `response_metadata`  | Raw              | Response metadata, e.g., response headers, logprobs, token counts.                                                                                                                                                      |
 
 #### content
@@ -243,37 +243,3 @@ At the moment, the output of the model will be in terms of LangChain messages, s
 need OpenAI format for the output as well.
 
 The [convert_to_openai_messages](https://python.langchain.com/api_reference/core/messages/langchain_core.messages.utils.convert_to_openai_messages.html) utility function can be used to convert from LangChain messages to OpenAI format.
-
-## Message IDs
-
-LangChain messages include an optional `id` field that serves as a unique identifier. Understanding when and how these IDs are assigned can be helpful for debugging, tracing, and working with message history.
-
-### When Messages Get IDs
-
-Messages receive IDs in the following scenarios:
-
-**Automatically assigned by LangChain:**
-- When generated through chat model invocation (`.invoke()`, `.stream()`, `.astream()`) with an active run manager/tracing context
-- IDs follow the format:
-    - `run-$RUN_ID` (e.g., `run-ba48f958-6402-41a5-b461-5e250a4ebd36-0`)
-    - `run-$RUN_ID-$IDX` (e.g., `run-ba48f958-6402-41a5-b461-5e250a4ebd36-1`) when there are multiple generations from a single chat model invocation.
-
-**Provider-assigned IDs (highest priority):**
-- When the model provider assigns its own ID to the message
-- These take precedence over LangChain-generated run IDs
-- Format varies by provider
-
-### When Messages Don't Get IDs
-
-Messages will **not** receive IDs in these situations:
-
-- **Manual message creation**: Messages created directly (e.g., `AIMessage(content="hello")`) without going through chat models
-- **No run manager context**: When there's no active callback/tracing infrastructure
-
-### ID Priority System
-
-LangChain follows a clear precedence system for message IDs:
-
-1. **Provider-assigned IDs** (highest priority): IDs from the model provider
-2. **LangChain run IDs** (medium priority): IDs starting with `run-`
-3. **Manual IDs** (lowest priority): IDs explicitly set by users

docs/docs/concepts/multimodality.mdx

@@ -14,7 +14,7 @@
 * [Chat models](/docs/concepts/chat_models)
 * [Messages](/docs/concepts/messages)
 :::
-
+ 
 LangChain supports multimodal data as input to chat models:
 
 1. Following provider-specific formats

docs/docs/concepts/prompt_templates.mdx

@@ -53,29 +53,17 @@ This is how you use MessagesPlaceholder.
 
 ```python
 from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
-from langchain_core.messages import HumanMessage, AIMessage
+from langchain_core.messages import HumanMessage
 
 prompt_template = ChatPromptTemplate([
     ("system", "You are a helpful assistant"),
     MessagesPlaceholder("msgs")
 ])
 
-# Simple example with one message
 prompt_template.invoke({"msgs": [HumanMessage(content="hi!")]})
-
-# More complex example with conversation history
-messages_to_pass = [
-    HumanMessage(content="What's the capital of France?"),
-    AIMessage(content="The capital of France is Paris."),
-    HumanMessage(content="And what about Germany?")
-]
-
-formatted_prompt = prompt_template.invoke({"msgs": messages_to_pass})
-print(formatted_prompt)
 ```
 
-
-This will produce a list of four messages total: the system message plus the three messages we passed in (two HumanMessages and one AIMessage).
+This will produce a list of two messages, the first one being a system message, and the second one being the HumanMessage we passed in.
 If we had passed in 5 messages, then it would have produced 6 messages in total (the system message plus the 5 passed in).
 This is useful for letting a list of messages be slotted into a particular spot.
 

docs/docs/concepts/rag.mdx

@@ -8,7 +8,7 @@
 
 ## Overview
 
-Retrieval Augmented Generation (RAG) is a powerful technique that enhances [language models](/docs/concepts/chat_models/) by combining them with external knowledge bases.
+Retrieval Augmented Generation (RAG) is a powerful technique that enhances [language models](/docs/concepts/chat_models/) by combining them with external knowledge bases. 
 RAG addresses [a key limitation of models](https://www.glean.com/blog/how-to-build-an-ai-assistant-for-the-enterprise): models rely on fixed training datasets, which can lead to outdated or incomplete information.
 When given a query, RAG systems first search a knowledge base for relevant information.
 The system then incorporates this retrieved information into the model's prompt.
@@ -44,7 +44,7 @@ See our conceptual guide on [retrieval](/docs/concepts/retrieval/).
 
 ## Adding external knowledge
 
-With a retrieval system in place, we need to pass knowledge from this system to the model.
+With a retrieval system in place, we need to pass knowledge from this system to the model. 
 A RAG pipeline typically achieves this following these steps:
 
 - Receive an input query.
@@ -59,12 +59,12 @@ from langchain_openai import ChatOpenAI
 from langchain_core.messages import SystemMessage, HumanMessage
 
 # Define a system prompt that tells the model how to use the retrieved context
-system_prompt = """You are an assistant for question-answering tasks.
-Use the following pieces of retrieved context to answer the question.
-If you don't know the answer, just say that you don't know.
+system_prompt = """You are an assistant for question-answering tasks. 
+Use the following pieces of retrieved context to answer the question. 
+If you don't know the answer, just say that you don't know. 
 Use three sentences maximum and keep the answer concise.
 Context: {context}:"""
-
+    
 # Define a question
 question = """What are the main components of an LLM-powered autonomous agent system?"""
 
@@ -78,7 +78,7 @@ docs_text = "".join(d.page_content for d in docs)
 system_prompt_fmt = system_prompt.format(context=docs_text)
 
 # Create a model
-model = ChatOpenAI(model="gpt-4o", temperature=0)
+model = ChatOpenAI(model="gpt-4o", temperature=0) 
 
 # Generate a response
 questions = model.invoke([SystemMessage(content=system_prompt_fmt),

docs/docs/concepts/retrieval.mdx

@@ -10,28 +10,28 @@
 :::
 
 :::danger[Security]
-
+ 
 Some of the concepts reviewed here utilize models to generate queries (e.g., for SQL or graph databases).
-There are inherent risks in doing this.
-Make sure that your database connection permissions are scoped as narrowly as possible for your application's needs.
-This will mitigate, though not eliminate, the risks of building a model-driven system capable of querying databases.
+There are inherent risks in doing this. 
+Make sure that your database connection permissions are scoped as narrowly as possible for your application's needs. 
+This will mitigate, though not eliminate, the risks of building a model-driven system capable of querying databases. 
 For more on general security best practices, see our [security guide](/docs/security/).
 
 :::
 
-## Overview
+## Overview 
 
-Retrieval systems are fundamental to many AI applications, efficiently identifying relevant information from large datasets.
+Retrieval systems are fundamental to many AI applications, efficiently identifying relevant information from large datasets. 
 These systems accommodate various data formats:
 
 - Unstructured text (e.g., documents) is often stored in vector stores or lexical search indexes.
 - Structured data is typically housed in relational or graph databases with defined schemas.
 
-Despite the growing diversity in data formats, modern AI applications increasingly aim to make all types of data accessible through natural language interfaces.
-Models play a crucial role in this process by translating natural language queries into formats compatible with the underlying search index or database.
+Despite the growing diversity in data formats, modern AI applications increasingly aim to make all types of data accessible through natural language interfaces. 
+Models play a crucial role in this process by translating natural language queries into formats compatible with the underlying search index or database. 
 This translation enables more intuitive and flexible interactions with complex data structures.
 
-## Key concepts
+## Key concepts 
 
 ![Retrieval](/img/retrieval_concept.png)
 
@@ -39,20 +39,20 @@ This translation enables more intuitive and flexible interactions with complex d
 
 (2) **Information retrieval**: Search queries are used to fetch information from various retrieval systems.
 
-## Query analysis
+## Query analysis 
 
-While users typically prefer to interact with retrieval systems using natural language, these systems may require specific query syntax or benefit from certain keywords.
+While users typically prefer to interact with retrieval systems using natural language, these systems may require specific query syntax or benefit from certain keywords. 
 Query analysis serves as a bridge between raw user input and optimized search queries. Some common applications of query analysis include:
 
 1. **Query Re-writing**: Queries can be re-written or expanded to improve semantic or lexical searches.
 2. **Query Construction**: Search indexes may require structured queries (e.g., SQL for databases).
 
-Query analysis employs models to transform or construct optimized search queries from raw user input.
+Query analysis employs models to transform or construct optimized search queries from raw user input. 
 
 ### Query re-writing
 
-Retrieval systems should ideally handle a wide spectrum of user inputs, from simple and poorly worded queries to complex, multi-faceted questions.
-To achieve this versatility, a popular approach is to use models to transform raw user queries into more effective search queries.
+Retrieval systems should ideally handle a wide spectrum of user inputs, from simple and poorly worded queries to complex, multi-faceted questions. 
+To achieve this versatility, a popular approach is to use models to transform raw user queries into more effective search queries. 
 This transformation can range from simple keyword extraction to sophisticated query expansion and reformulation.
 Here are some key benefits of using models for query analysis in unstructured data retrieval:
 
@@ -87,7 +87,7 @@ class Questions(BaseModel):
     )
 
 # Create an instance of the model and enforce the output structure
-model = ChatOpenAI(model="gpt-4o", temperature=0)
+model = ChatOpenAI(model="gpt-4o", temperature=0) 
 structured_model = model.with_structured_output(Questions)
 
 # Define the system prompt
@@ -111,7 +111,7 @@ See our RAG from Scratch videos for a few different specific approaches:
 
 ### Query construction
 
-Query analysis also can focus on translating natural language queries into specialized query languages or filters.
+Query analysis also can focus on translating natural language queries into specialized query languages or filters. 
 This translation is crucial for effectively interacting with various types of databases that house structured or semi-structured data.
 
 1. **Structured Data examples**: For relational and graph databases, Domain-Specific Languages (DSLs) are used to query data.
@@ -129,10 +129,10 @@ These approaches leverage models to bridge the gap between user intent and the s
 | [Text to SQL](/docs/tutorials/sql_qa/)   | If users are asking questions that require information housed in a relational database, accessible via SQL.                          | This uses an LLM to transform user input into a SQL query.                                                                                                                                                                                           |
 | [Text-to-Cypher](/docs/tutorials/graph/) | If users are asking questions that require information housed in a graph database, accessible via Cypher.                            | This uses an LLM to transform user input into a Cypher query.                                                                                                                                                                                        |
 
-As an example, here is how to use the `SelfQueryRetriever` to convert natural language queries into metadata filters.
+As an example, here is how to use the `SelfQueryRetriever` to convert natural language queries into metadata filters.  
 
 ```python
-metadata_field_info = schema_for_metadata
+metadata_field_info = schema_for_metadata 
 document_content_description = "Brief summary of a movie"
 llm = ChatOpenAI(temperature=0)
 retriever = SelfQueryRetriever.from_llm(
@@ -149,20 +149,20 @@ retriever = SelfQueryRetriever.from_llm(
 * See our [blog post overview](https://blog.langchain.dev/query-construction/).
 * See our RAG from Scratch video on [query construction](https://youtu.be/kl6NwWYxvbM?feature=shared).
 
-:::
+::: 
 
-## Information retrieval
+## Information retrieval 
 
 ### Common retrieval systems
 
 #### Lexical search indexes
 
-Many search engines are based upon matching words in a query to the words in each document.
+Many search engines are based upon matching words in a query to the words in each document. 
 This approach is called lexical retrieval, using search [algorithms that are typically based upon word frequencies](https://cameronrwolfe.substack.com/p/the-basics-of-ai-powered-vector-search?utm_source=profile&utm_medium=reader2).
 The intution is simple: a word appears frequently both in the user’s query and a particular document, then this document might be a good match.
 
 The particular data structure used to implement this is often an [*inverted index*](https://www.geeksforgeeks.org/inverted-index/).
-This types of index contains a list of words and a mapping of each word to a list of locations at which it occurs in various documents.
+This types of index contains a list of words and a mapping of each word to a list of locations at which it occurs in various documents. 
 Using this data structure, it is possible to efficiently match the words in search queries to the documents in which they appear.
 [BM25](https://en.wikipedia.org/wiki/Okapi_BM25#:~:text=BM25%20is%20a%20bag%2Dof,slightly%20different%20components%20and%20parameters.) and [TF-IDF](https://en.wikipedia.org/wiki/Tf%E2%80%93idf) are [two popular lexical search algorithms](https://cameronrwolfe.substack.com/p/the-basics-of-ai-powered-vector-search?utm_source=profile&utm_medium=reader2).
 
@@ -171,13 +171,13 @@ Using this data structure, it is possible to efficiently match the words in sear
 * See the [BM25](/docs/integrations/retrievers/bm25/) retriever integration.
 * See the [Elasticsearch](/docs/integrations/retrievers/elasticsearch_retriever/) retriever integration.
 
-:::
+::: 
 
 #### Vector indexes
 
 Vector indexes are an alternative way to index and store unstructured data.
-See our conceptual guide on [vectorstores](/docs/concepts/vectorstores/) for a detailed overview.
-In short, rather than using word frequencies, vectorstores use an [embedding model](/docs/concepts/embedding_models/) to compress documents into high-dimensional vector representation.
+See our conceptual guide on [vectorstores](/docs/concepts/vectorstores/) for a detailed overview.  
+In short, rather than using word frequencies, vectorstores use an [embedding model](/docs/concepts/embedding_models/) to compress documents into high-dimensional vector representation. 
 This allows for efficient similarity search over embedding vectors using simple mathematical operations like cosine similarity.
 
 :::info[Further reading]
@@ -190,9 +190,9 @@ This allows for efficient similarity search over embedding vectors using simple
 
 #### Relational databases
 
-Relational databases are a fundamental type of structured data storage used in many applications.
-They organize data into tables with predefined schemas, where each table represents an entity or relationship.
-Data is stored in rows (records) and columns (attributes), allowing for efficient querying and manipulation through SQL (Structured Query Language).
+Relational databases are a fundamental type of structured data storage used in many applications. 
+They organize data into tables with predefined schemas, where each table represents an entity or relationship. 
+Data is stored in rows (records) and columns (attributes), allowing for efficient querying and manipulation through SQL (Structured Query Language). 
 Relational databases excel at maintaining data integrity, supporting complex queries, and handling relationships between different data entities.
 
 :::info[Further reading]
@@ -204,8 +204,8 @@ Relational databases excel at maintaining data integrity, supporting complex que
 
 #### Graph databases
 
-Graph databases are a specialized type of database designed to store and manage highly interconnected data.
-Unlike traditional relational databases, graph databases use a flexible structure consisting of nodes (entities), edges (relationships), and properties.
+Graph databases are a specialized type of database designed to store and manage highly interconnected data. 
+Unlike traditional relational databases, graph databases use a flexible structure consisting of nodes (entities), edges (relationships), and properties. 
 This structure allows for efficient representation and querying of complex, interconnected data.
 Graph databases store data in a graph structure, with nodes, edges, and properties.
 They are particularly useful for storing and querying complex relationships between data points, such as social networks, supply-chain management, fraud detection, and recommendation services
@@ -213,12 +213,12 @@ They are particularly useful for storing and querying complex relationships betw
 :::info[Further reading]
 
 * See our [tutorial](/docs/tutorials/graph/) for working with graph databases.
-* See our [list of graph database integrations](/docs/integrations/graphs/).
+* See our [list of graph database integrations](/docs/integrations/graphs/). 
 * See Neo4j's [starter kit for LangChain](https://neo4j.com/developer-blog/langchain-neo4j-starter-kit/).
 
 :::
 
-### Retriever
+### Retriever  
 
 LangChain provides a unified interface for interacting with various retrieval systems through the [retriever](/docs/concepts/retrievers/) concept. The interface is straightforward:
 

docs/docs/concepts/retrievers.mdx

@@ -23,16 +23,16 @@ The LangChain [retriever](/docs/concepts/retrievers/) interface is straightforwa
 ## Key concept
 
 ![Retriever](/img/retriever_concept.png)
-
+ 
 All retrievers implement a simple interface for retrieving documents using natural language queries.
 
-## Interface
+## Interface 
 
-The only requirement for a retriever is the ability to accepts a query and return documents.
+The only requirement for a retriever is the ability to accepts a query and return documents. 
 In particular, [LangChain's retriever class](https://python.langchain.com/api_reference/core/retrievers/langchain_core.retrievers.BaseRetriever.html#) only requires that the `_get_relevant_documents` method is implemented, which takes a `query: str` and returns a list of [Document](https://python.langchain.com/api_reference/core/documents/langchain_core.documents.base.Document.html) objects that are most relevant to the query.
 The underlying logic used to get relevant documents is specified by the retriever and can be whatever is most useful for the application.
 
-A LangChain retriever is a [runnable](/docs/how_to/lcel_cheatsheet/), which is a standard interface for LangChain components.
+A LangChain retriever is a [runnable](/docs/how_to/lcel_cheatsheet/), which is a standard interface for LangChain components. 
 This means that it has a few common methods, including `invoke`, that are used to interact with it. A retriever can be invoked with a query:
 
 ```python
@@ -42,23 +42,23 @@ docs = retriever.invoke(query)
 Retrievers return a list of [Document](https://python.langchain.com/api_reference/core/documents/langchain_core.documents.base.Document.html) objects, which have two attributes:
 
 * `page_content`: The content of this document. Currently is a string.
-* `metadata`: Arbitrary metadata associated with this document (e.g., document id, file name, source, etc).
+* `metadata`: Arbitrary metadata associated with this document (e.g., document id, file name, source, etc). 
 
 :::info[Further reading]
 
 * See our [how-to guide](/docs/how_to/custom_retriever/) on building your own custom retriever.
 
 :::
-
+ 
 ## Common types
 
 Despite the flexibility of the retriever interface, a few common types of retrieval systems are frequently used.
 
 ### Search apis
 
-It's important to note that retrievers don't need to actually *store* documents.
-For example, we can build retrievers on top of search APIs that simply return search results!
-See our retriever integrations with [Amazon Kendra](/docs/integrations/retrievers/amazon_kendra_retriever/) or [Wikipedia Search](/docs/integrations/retrievers/wikipedia/).
+It's important to note that retrievers don't need to actually *store* documents. 
+For example, we can build retrievers on top of search APIs that simply return search results! 
+See our retriever integrations with [Amazon Kendra](/docs/integrations/retrievers/amazon_kendra_retriever/) or [Wikipedia Search](/docs/integrations/retrievers/wikipedia/). 
 
 ### Relational or graph database
 
@@ -75,7 +75,7 @@ For example, you can build a retriever for a SQL database using text-to-SQL conv
 
 ### Lexical search
 
-As discussed in our conceptual review of [retrieval](/docs/concepts/retrieval/), many search engines are based upon matching words in a query to the words in each document.
+As discussed in our conceptual review of [retrieval](/docs/concepts/retrieval/), many search engines are based upon matching words in a query to the words in each document. 
 [BM25](https://en.wikipedia.org/wiki/Okapi_BM25#:~:text=BM25%20is%20a%20bag%2Dof,slightly%20different%20components%20and%20parameters.) and [TF-IDF](https://en.wikipedia.org/wiki/Tf%E2%80%93idf) are [two popular lexical search algorithms](https://cameronrwolfe.substack.com/p/the-basics-of-ai-powered-vector-search?utm_source=profile&utm_medium=reader2).
 LangChain has retrievers for many popular lexical search algorithms / engines.
 
@@ -85,11 +85,11 @@ LangChain has retrievers for many popular lexical search algorithms / engines.
 * See the [TF-IDF](/docs/integrations/retrievers/tf_idf/) retriever integration.
 * See the [Elasticsearch](/docs/integrations/retrievers/elasticsearch_retriever/) retriever integration.
 
-:::
+::: 
 
-### Vector store
+### Vector store 
 
-[Vector stores](/docs/concepts/vectorstores/) are a powerful and efficient way to index and retrieve unstructured data.
+[Vector stores](/docs/concepts/vectorstores/) are a powerful and efficient way to index and retrieve unstructured data. 
 A vectorstore can be used as a retriever by calling the `as_retriever()` method.
 
 ```python
@@ -99,7 +99,7 @@ retriever = vectorstore.as_retriever()
 
 ## Advanced retrieval patterns
 
-### Ensemble
+### Ensemble 
 
 Because the retriever interface is so simple, returning a list of `Document` objects given a search query, it is possible to combine multiple retrievers using ensembling.
 This is particularly useful when you have multiple retrievers that are good at finding different types of relevant documents.
@@ -112,24 +112,24 @@ ensemble_retriever = EnsembleRetriever(
 )
 ```
 
-When ensembling, how do we combine search results from many retrievers?
+When ensembling, how do we combine search results from many retrievers? 
 This motivates the concept of re-ranking, which takes the output of multiple retrievers and combines them using a more sophisticated algorithm such as [Reciprocal Rank Fusion (RRF)](https://plg.uwaterloo.ca/~gvcormac/cormacksigir09-rrf.pdf).
 
-### Source document retention
+### Source document retention 
 
 Many retrievers utilize some kind of index to make documents easily searchable.
-The process of indexing can include a transformation step (e.g., vectorstores often use document splitting).
+The process of indexing can include a transformation step (e.g., vectorstores often use document splitting). 
 Whatever transformation is used, can be very useful to retain a link between the *transformed document* and the original, giving the retriever the ability to return the *original* document.
 
 ![Retrieval with full docs](/img/retriever_full_docs.png)
 
 This is particularly useful in AI applications, because it ensures no loss in document context for the model.
-For example, you may use small chunk size for indexing documents in a vectorstore.
-If you return *only* the chunks as the retrieval result, then the model will have lost the original document context for the chunks.
+For example, you may use small chunk size for indexing documents in a vectorstore. 
+If you return *only* the chunks as the retrieval result, then the model will have lost the original document context for the chunks. 
 
-LangChain has two different retrievers that can be used to address this challenge.
-The [Multi-Vector](/docs/how_to/multi_vector/) retriever allows the user to use any document transformation (e.g., use an LLM to write a summary of the document) for indexing while retaining linkage to the source document.
-The [ParentDocument](/docs/how_to/parent_document_retriever/) retriever links document chunks from a text-splitter transformation for indexing while retaining linkage to the source document.
+LangChain has two different retrievers that can be used to address this challenge. 
+The [Multi-Vector](/docs/how_to/multi_vector/) retriever allows the user to use any document transformation (e.g., use an LLM to write a summary of the document) for indexing while retaining linkage to the source document. 
+The [ParentDocument](/docs/how_to/parent_document_retriever/) retriever links document chunks from a text-splitter transformation for indexing while retaining linkage to the source document. 
 
 | Name                                                      | Index Type                    | Uses an LLM               | When to Use                                                                                                                             | Description                                                                                                                                                                                                              |
 |-----------------------------------------------------------|-------------------------------|---------------------------|-----------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|

docs/docs/concepts/runnables.mdx

@@ -107,7 +107,7 @@ The Runnable interface provides methods to get the [JSON Schema](https://json-sc
 
 These APIs are mostly used internally for unit-testing and by [LangServe](/docs/concepts/architecture#langserve) which uses the APIs for input validation and generation of [OpenAPI documentation](https://www.openapis.org/).
 
-In addition, to the input and output types, some Runnables have been set up with additional run time configuration options.
+In addition, to the input and output types, some Runnables have been set up with additional run time configuration options. 
 There are corresponding APIs to get the Pydantic Schema and JSON Schema of the configuration options for the Runnable.
 Please see the [Configurable Runnables](#configurable-runnables) section for more information.
 
@@ -151,12 +151,12 @@ Passing `config` to the `invoke` method is done like so:
 
 ```python
 some_runnable.invoke(
-   some_input,
+   some_input, 
    config={
-      'run_name': 'my_run',
-      'tags': ['tag1', 'tag2'],
+      'run_name': 'my_run', 
+      'tags': ['tag1', 'tag2'], 
       'metadata': {'key': 'value'}
-
+      
    }
 )
 ```
@@ -185,13 +185,13 @@ There are two main patterns by which new `Runnables` are created:
     foo_runnable = RunnableLambda(foo)
     ```
 
-LangChain will try to propagate `RunnableConfig` automatically for both of the patterns.
+LangChain will try to propagate `RunnableConfig` automatically for both of the patterns. 
 
 For handling the second pattern, LangChain relies on Python's [contextvars](https://docs.python.org/3/library/contextvars.html).
 
 In Python 3.11 and above, this works out of the box, and you do not need to do anything special to propagate the `RunnableConfig` to the sub-calls.
 
-In Python 3.9 and 3.10, if you are using **async code**, you need to manually pass the `RunnableConfig` through to the `Runnable` when invoking it.
+In Python 3.9 and 3.10, if you are using **async code**, you need to manually pass the `RunnableConfig` through to the `Runnable` when invoking it. 
 
 This is due to a limitation in [asyncio's tasks](https://docs.python.org/3/library/asyncio-task.html#asyncio.create_task)  in Python 3.9 and 3.10 which did
 not accept a `context` argument.
@@ -201,7 +201,7 @@ Propagating the `RunnableConfig` manually is done like so:
 ```python
 async def foo(input, config): # <-- Note the config argument
     return await bar_runnable.ainvoke(input, config=config)
-
+    
 foo_runnable = RunnableLambda(foo)
 ```
 
@@ -235,7 +235,7 @@ The attributes will also be propagated to [callbacks](/docs/concepts/callbacks),
 This is an advanced feature that is unnecessary for most users.
 :::
 
-You may need to set a custom `run_id` for a given run, in case you want
+You may need to set a custom `run_id` for a given run, in case you want 
 to reference it later or correlate it with other systems.
 
 The `run_id` MUST be a valid UUID string and **unique** for each run. It is used to identify
@@ -249,7 +249,7 @@ import uuid
 run_id = uuid.uuid4()
 
 some_runnable.invoke(
-   some_input,
+   some_input, 
    config={
       'run_id': run_id
    }
@@ -292,7 +292,7 @@ In addition, you can use it to specify any custom configuration options to pass
 
 ### Setting callbacks
 
-Use this option to configure [callbacks](/docs/concepts/callbacks) for the runnable at
+Use this option to configure [callbacks](/docs/concepts/callbacks) for the runnable at 
 runtime. The callbacks will be passed to all sub-calls made by the runnable.
 
 ```python

docs/docs/concepts/streaming.mdx

@@ -52,7 +52,7 @@ In addition, there is a **legacy** async [astream_log](https://python.langchain.
 
 The `stream()` method returns an iterator that yields chunks of output synchronously as they are produced. You can use a `for` loop to process each chunk in real-time. For example, when using an LLM, this allows the output to be streamed incrementally as it is generated, reducing the wait time for users.
 
-The type of chunk yielded by the `stream()` and `astream()` methods depends on the component being streamed. For example, when streaming from an [LLM](/docs/concepts/chat_models) each component will be an [AIMessageChunk](/docs/concepts/messages#aimessagechunk); however, for other components, the chunk may be different.
+The type of chunk yielded by the `stream()` and `astream()` methods depends on the component being streamed. For example, when streaming from an [LLM](/docs/concepts/chat_models) each component will be an [AIMessageChunk](/docs/concepts/messages#aimessagechunk); however, for other components, the chunk may be different. 
 
 The `stream()` method returns an iterator that yields these chunks as they are produced. For example,
 
@@ -99,7 +99,7 @@ If you compose multiple Runnables using [LangChain’s Expression Language (LCEL
 <span data-heading-keywords="astream_events,stream_events,stream events"></span>
 
 :::tip
-Use the `astream_events` API to access custom data and intermediate outputs from LLM applications built entirely with [LCEL](/docs/concepts/lcel).
+Use the `astream_events` API to access custom data and intermediate outputs from LLM applications built entirely with [LCEL](/docs/concepts/lcel). 
 
 While this API is available for use with [LangGraph](/docs/concepts/architecture#langgraph) as well, it is usually not necessary when working with LangGraph, as the `stream` and `astream` methods provide comprehensive streaming capabilities for LangGraph graphs.
 :::
@@ -119,7 +119,7 @@ from langchain_core.output_parsers import StrOutputParser
 from langchain_core.prompts import ChatPromptTemplate
 from langchain_anthropic import ChatAnthropic
 
-model = ChatAnthropic(model="claude-3-7-sonnet-20250219")
+model = ChatAnthropic(model="claude-3-sonnet-20240229")
 
 prompt = ChatPromptTemplate.from_template("tell me a joke about {topic}")
 parser = StrOutputParser()
@@ -148,7 +148,7 @@ LangChain simplifies streaming from [chat models](/docs/concepts/chat_models) by
 
 ### How It Works
 
-When you call the `invoke` (or `ainvoke`) method on a chat model, LangChain will automatically switch to streaming mode if it detects that you are trying to stream the overall application.
+When you call the `invoke` (or `ainvoke`) method on a chat model, LangChain will automatically switch to streaming mode if it detects that you are trying to stream the overall application. 
 
 Under the hood, it'll have `invoke` (or `ainvoke`) use the `stream` (or `astream`) method to generate its output. The result of the invocation will be the same as far as the code that was using `invoke` is concerned; however, while the chat model is being streamed, LangChain will take care of invoking `on_llm_new_token` events in LangChain's [callback system](/docs/concepts/callbacks). These callback events
 allow LangGraph `stream`/`astream` and `astream_events` to surface the chat model's output in real-time.
@@ -158,14 +158,14 @@ Example:
 ```python
 def node(state):
     ...
-    # The code below uses the invoke method, but LangChain will
+    # The code below uses the invoke method, but LangChain will 
     # automatically switch to streaming mode
-    # when it detects that the overall
+    # when it detects that the overall 
     # application is being streamed.
     ai_message = model.invoke(state["messages"])
     ...
 
-for chunk in compiled_graph.stream(..., mode="messages"):
+for chunk in compiled_graph.stream(..., mode="messages"): 
     ...
 ```
 ## Async Programming

docs/docs/concepts/structured_outputs.mdx

@@ -1,15 +1,15 @@
 # Structured outputs
 
-## Overview
+## Overview 
 
-For many applications, such as chatbots, models need to respond to users directly in natural language.
-However, there are scenarios where we need models to output in a *structured format*.
+For many applications, such as chatbots, models need to respond to users directly in natural language. 
+However, there are scenarios where we need models to output in a *structured format*. 
 For example, we might want to store the model output in a database and ensure that the output conforms to the database schema.
 This need motivates the concept of structured output, where models can be instructed to respond with a particular output structure.
 
 ![Structured output](/img/structured_output.png)
 
-## Key concepts
+## Key concepts 
 
 1. **Schema definition:** The output structure is represented as a schema, which can be defined in several ways.<br/>
 2. **Returning structured output:** The model is given this schema, and is instructed to return output that conforms to it.
@@ -18,7 +18,7 @@ This need motivates the concept of structured output, where models can be instru
 
 This pseudocode illustrates the recommended workflow when using structured output.
 LangChain provides a method, [`with_structured_output()`](/docs/how_to/structured_output/#the-with_structured_output-method), that automates the process of binding the schema to the [model](/docs/concepts/chat_models/) and parsing the output.
-This helper function is available for all model providers that support structured output.
+This helper function is available for all model providers that support structured output. 
 
 ```python
 # Define schema
@@ -29,25 +29,9 @@ model_with_structure = model.with_structured_output(schema)
 structured_output = model_with_structure.invoke(user_input)
 ```
 
-:::warning[Tool Order Matters]
-
-When combining structured output with additional tools, bind tools **first**, then apply structured output:
-
-```python
-# Correct
-model_with_tools = model.bind_tools([tool1, tool2])
-structured_model = model_with_tools.with_structured_output(schema)
-
-# Incorrect - will cause tool resolution errors
-structured_model = model.with_structured_output(schema)
-broken_model = structured_model.bind_tools([tool1, tool2])
-```
-
-:::
-
 ## Schema definition
 
-The central concept is that the output structure of model responses needs to be represented in some way.
+The central concept is that the output structure of model responses needs to be represented in some way. 
 While types of objects you can use depend on the model you're working with, there are common types of objects that are typically allowed or recommended for structured output in Python.
 
 The simplest and most common format for structured output is a JSON-like structure, which in Python can be represented as a dictionary (dict) or list (list).
@@ -61,7 +45,7 @@ JSON objects (or dicts in Python) are often used directly when the tool requires
 ```
 
 As a second example, [Pydantic](https://docs.pydantic.dev/latest/) is particularly useful for defining structured output schemas because it offers type hints and validation.
-Here's an example of a Pydantic schema:
+Here's an example of a Pydantic schema: 
 
 ```python
 from pydantic import BaseModel, Field
@@ -75,7 +59,7 @@ class ResponseFormatter(BaseModel):
 ## Returning structured output
 
 With a schema defined, we need a way to instruct the model to use it.
-While one approach is to include this schema in the prompt and *ask nicely* for the model to use it, this is not recommended.
+While one approach is to include this schema in the prompt and *ask nicely* for the model to use it, this is not recommended. 
 Several more powerful methods that utilizes native features in the model provider's API are available.
 
 ### Using tool calling
@@ -94,7 +78,7 @@ model_with_tools = model.bind_tools([ResponseFormatter])
 ai_msg = model_with_tools.invoke("What is the powerhouse of the cell?")
 ```
 
-The arguments of the tool call are already extracted as a dictionary.
+The arguments of the tool call are already extracted as a dictionary. 
 This dictionary can be optionally parsed into a Pydantic object, matching our original `ResponseFormatter` schema.
 
 ```python
@@ -108,7 +92,7 @@ pydantic_object = ResponseFormatter.model_validate(ai_msg.tool_calls[0]["args"])
 
 ### JSON mode
 
-In addition to tool calling, some model providers support a feature called `JSON mode`.
+In addition to tool calling, some model providers support a feature called `JSON mode`. 
 This supports JSON schema definition as input and enforces the model to produce a conforming JSON output.
 You can find a table of model providers that support JSON mode [here](/docs/integrations/chat/).
 Here is an example of how to use JSON mode with OpenAI:
@@ -121,21 +105,21 @@ ai_msg
 {'random_ints': [45, 67, 12, 34, 89, 23, 78, 56, 90, 11]}
 ```
 
-## Structured output method
+## Structured output method 
 
-There are a few challenges when producing structured output with the above methods:
+There are a few challenges when producing structured output with the above methods: 
 
-1. When tool calling is used, tool call arguments needs to be parsed from a dictionary back to the original schema.<br/>
+1. When tool calling is used, tool call arguments needs to be parsed from a dictionary back to the original schema.<br/>  
 
-2. In addition, the model needs to be instructed to *always* use the tool when we want to enforce structured output, which is a provider specific setting.<br/>
+2. In addition, the model needs to be instructed to *always* use the tool when we want to enforce structured output, which is a provider specific setting.<br/> 
 
-3. When JSON mode is used, the output needs to be parsed into a JSON object.
+3. When JSON mode is used, the output needs to be parsed into a JSON object. 
 
 With these challenges in mind, LangChain provides a helper function (`with_structured_output()`) to streamline the process.
 
 ![Diagram of with structured output](/img/with_structured_output.png)
 
-This both binds the schema to the model as a tool and parses the output to the specified output schema.
+This both binds the schema to the model as a tool and parses the output to the specified output schema. 
 
 ```python
 # Bind the schema to the model

docs/docs/concepts/testing.mdx

@@ -23,9 +23,9 @@ def test_convert_to_openai_messages():
             ToolCall(name='parrot_multiply_tool', id='1', args={'a': 2, 'b': 3}),
         ]
     )
-
+    
     result = convert_to_openai_messages(ai_message)
-
+    
     expected = {
         "role": "assistant",
         "tool_calls": [

docs/docs/concepts/text_llms.mdx

@@ -7,4 +7,4 @@ You are probably looking for the [Chat Model Concept Guide](/docs/concepts/chat_
 LangChain has implementations for older language models that take a string as input and return a string as output. These models are typically named without the "Chat" prefix (e.g., `Ollama`, `Anthropic`, `OpenAI`, etc.), and may include the "LLM" suffix (e.g., `OllamaLLM`, `AnthropicLLM`, `OpenAILLM`, etc.). These models implement the [BaseLLM](https://python.langchain.com/api_reference/core/language_models/langchain_core.language_models.llms.BaseLLM.html#langchain_core.language_models.llms.BaseLLM) interface.
 
 Users should be using almost exclusively the newer [Chat Models](/docs/concepts/chat_models) as most
-model providers have adopted a chat like interface for interacting with language models.
+model providers have adopted a chat like interface for interacting with language models.

docs/docs/concepts/text_splitters.mdx

@@ -69,7 +69,7 @@ texts = text_splitter.split_text(document)
 
 ### Text-structured based
 
-Text is naturally organized into hierarchical units such as paragraphs, sentences, and words.
+Text is naturally organized into hierarchical units such as paragraphs, sentences, and words. 
 We can leverage this inherent structure to inform our splitting strategy, creating split that maintain natural language flow, maintain semantic coherence within split, and adapts to varying levels of text granularity.
 LangChain's [`RecursiveCharacterTextSplitter`](/docs/how_to/recursive_text_splitter/) implements this concept:
 - The `RecursiveCharacterTextSplitter` attempts to keep larger units (e.g., paragraphs) intact.
@@ -92,7 +92,7 @@ texts = text_splitter.split_text(document)
 
 ### Document-structured based
 
-Some documents have an inherent structure, such as HTML, Markdown, or JSON files.
+Some documents have an inherent structure, such as HTML, Markdown, or JSON files. 
 In these cases, it's beneficial to split the document based on its structure, as it often naturally groups semantically related text.
 Key benefits of structure-based splitting:
 - Preserves the logical organization of the document
@@ -116,7 +116,7 @@ Examples of structure-based splitting:
 
 ### Semantic meaning based
 
-Unlike the previous methods, semantic-based splitting actually considers the *content* of the text.
+Unlike the previous methods, semantic-based splitting actually considers the *content* of the text. 
 While other approaches use document or text structure as proxies for semantic meaning, this method directly analyzes the text's semantics.
 There are several ways to implement this, but conceptually the approach is split text when there are significant changes in text *meaning*.
 As an example, we can use a sliding window approach to generate embeddings, and compare the embeddings to find significant differences:

docs/docs/concepts/tokens.mdx

@@ -55,4 +55,4 @@ According to the OpenAI post, the approximate token counts for English text are
 
 * 1 token ~= 4 chars in English
 * 1 token ~= ¾ words
-* 100 tokens ~= 75 words
+* 100 tokens ~= 75 words

docs/docs/concepts/tool_calling.mdx

@@ -6,7 +6,7 @@
 :::
 
 
-## Overview
+## Overview 
 
 Many AI applications interact directly with humans. In these cases, it is appropriate for models to respond in natural language.
 But what about cases where we want a model to also interact *directly* with systems, such as databases or an API?
@@ -14,12 +14,12 @@ These systems often have a particular input schema; for example, APIs frequently
 This need motivates the concept of *tool calling*. You can use [tool calling](https://platform.openai.com/docs/guides/function-calling/example-use-cases) to request model responses that match a particular schema.
 
 :::info
-You will sometimes hear the term `function calling`. We use this term interchangeably with `tool calling`.
+You will sometimes hear the term `function calling`. We use this term interchangeably with `tool calling`. 
 :::
 
 ![Conceptual overview of tool calling](/img/tool_calling_concept.png)
 
-## Key concepts
+## Key concepts 
 
 1. **Tool Creation:** Use the [@tool](https://python.langchain.com/api_reference/core/tools/langchain_core.tools.convert.tool.html) decorator to create a [tool](/docs/concepts/tools). A tool is an association between a function and its schema.<br/>
 2. **Tool Binding:** The tool needs to be connected to a model that supports tool calling. This gives the model awareness of the tool and the associated input schema required by the tool.<br/>
@@ -40,7 +40,7 @@ The tool call arguments can be passed directly to the tool.
 tools = [my_tool]
 # Tool binding
 model_with_tools = model.bind_tools(tools)
-# Tool calling
+# Tool calling 
 response = model_with_tools.invoke(user_input)
 ```
 
@@ -65,16 +65,16 @@ def multiply(a: int, b: int) -> int:
 
 :::
 
-## Tool binding
+## Tool binding 
 
-[Many](https://platform.openai.com/docs/guides/function-calling) [model providers](https://platform.openai.com/docs/guides/function-calling) support tool calling.
+[Many](https://platform.openai.com/docs/guides/function-calling) [model providers](https://platform.openai.com/docs/guides/function-calling) support tool calling. 
 
 :::tip
 See our [model integration page](/docs/integrations/chat/) for a list of providers that support tool calling.
 :::
 
-The central concept to understand is that LangChain provides a standardized interface for connecting tools to models.
-The `.bind_tools()` method can be used to specify which tools are available for a model to call.
+The central concept to understand is that LangChain provides a standardized interface for connecting tools to models. 
+The `.bind_tools()` method can be used to specify which tools are available for a model to call. 
 
 ```python
 model_with_tools = model.bind_tools(tools_list)
@@ -113,7 +113,7 @@ However, if we pass an input *relevant to the tool*, the model should choose to
 result = llm_with_tools.invoke("What is 2 multiplied by 3?")
 ```
 
-As before, the output `result` will be an `AIMessage`.
+As before, the output `result` will be an `AIMessage`. 
 But, if the tool was called, `result` will have a `tool_calls` [attribute](https://python.langchain.com/api_reference/core/messages/langchain_core.messages.ai.AIMessage.html#langchain_core.messages.ai.AIMessage.tool_calls).
 This attribute includes everything needed to execute the tool, including the tool name and input arguments:
 

docs/docs/concepts/tools.mdx

@@ -6,7 +6,7 @@
 
 ## Overview
 
-The **tool** abstraction in LangChain associates a Python **function** with a **schema** that defines the function's **name**, **description** and **expected arguments**.
+The **tool** abstraction in LangChain associates a Python **function** with a **schema** that defines the function's **name**, **description** and **expected arguments**. 
 
 **Tools** can be passed to [chat models](/docs/concepts/chat_models) that support [tool calling](/docs/concepts/tool_calling) allowing the model to request the execution of a specific function with specific inputs.
 
@@ -31,7 +31,7 @@ The key attributes that correspond to the tool's **schema**:
 The key methods to execute the function associated with the **tool**:
 
 - **invoke**: Invokes the tool with the given arguments.
-- **ainvoke**: Invokes the tool with the given arguments, asynchronously. Used for [async programming with LangChain](/docs/concepts/async).
+- **ainvoke**: Invokes the tool with the given arguments, asynchronously. Used for [async programming with Langchain](/docs/concepts/async).
 
 ## Create tools using the `@tool` decorator
 
@@ -68,10 +68,10 @@ You can also inspect the tool's schema and other properties:
 ```python
 print(multiply.name) # multiply
 print(multiply.description) # Multiply two numbers.
-print(multiply.args)
+print(multiply.args) 
 # {
-# 'type': 'object',
-# 'properties': {'a': {'type': 'integer'}, 'b': {'type': 'integer'}},
+# 'type': 'object', 
+# 'properties': {'a': {'type': 'integer'}, 'b': {'type': 'integer'}}, 
 # 'required': ['a', 'b']
 # }
 ```
@@ -89,14 +89,14 @@ Please see the [API reference for @tool](https://python.langchain.com/api_refere
 
 ## Tool artifacts
 
-**Tools** are utilities that can be called by a model, and whose outputs are designed to be fed back to a model. Sometimes, however, there are artifacts of a tool's execution that we want to make accessible to downstream components in our chain or agent, but that we don't want to expose to the model itself. For example if a tool returns a custom object, a dataframe or an image, we may want to pass some metadata about this output to the model without passing the actual output. At the same time, we may want to be able to access this full output elsewhere, for example in downstream tools.
+**Tools** are utilities that can be called by a model, and whose outputs are designed to be fed back to a model. Sometimes, however, there are artifacts of a tool's execution that we want to make accessible to downstream components in our chain or agent, but that we don't want to expose to the model itself. For example if a tool returns a custom object, a dataframe or an image, we may want to pass some metadata about this output to the model without passing the actual output to the model. At the same time, we may want to be able to access this full output elsewhere, for example in downstream tools.
 
 ```python
 @tool(response_format="content_and_artifact")
 def some_tool(...) -> Tuple[str, Any]:
     """Tool that does something."""
     ...
-    return 'Message for chat model', some_artifact
+    return 'Message for chat model', some_artifact 
 ```
 
 See [how to return artifacts from tools](/docs/how_to/tool_artifacts/) for more details.
@@ -134,7 +134,7 @@ def user_specific_tool(input_data: str, user_id: InjectedToolArg) -> str:
 Annotating the `user_id` argument with `InjectedToolArg` tells LangChain that this argument should not be exposed as part of the
 tool's schema.
 
-See [how to pass run time values to tools](/docs/how_to/tool_runtime/) for more details on how to use `InjectedToolArg`.
+See [how to pass run time values to tools](/docs/how_to/tool_runtime/) for more details on how to use `InjectedToolArg`.  
 
 
 ### RunnableConfig
@@ -171,26 +171,6 @@ Please see the [InjectedState](https://langchain-ai.github.io/langgraph/referenc
 
 Please see the [InjectedStore](https://langchain-ai.github.io/langgraph/reference/prebuilt/#langgraph.prebuilt.tool_node.InjectedStore) documentation for more details.
 
-## Tool Artifacts vs. Injected State
-
-Although similar conceptually, tool artifacts in LangChain and [injected state in LangGraph](https://langchain-ai.github.io/langgraph/reference/agents/#langgraph.prebuilt.tool_node.InjectedState) serve different purposes and operate at different levels of abstraction.
-
-**Tool Artifacts**
-
-- **Purpose:** Store and pass data between tool executions within a single chain/workflow
-- **Scope:** Limited to tool-to-tool communication
-- **Lifecycle:** Tied to individual tool calls and their immediate context
-- **Usage:** Temporary storage for intermediate results that tools need to share
-
-**Injected State (LangGraph)**
-
-- **Purpose:** Maintain persistent state across the entire graph execution
-- **Scope:** Global to the entire graph workflow
-- **Lifecycle:** Persists throughout the entire graph execution and can be saved/restored
-- **Usage:** Long-term state management, conversation memory, user context, workflow checkpointing
-
-Tool artifacts are ephemeral data passed between tools, while injected state is persistent workflow-level state that survives across multiple steps, tool calls, and even execution sessions in LangGraph.
-
 ## Best practices
 
 When designing tools to be used by models, keep the following in mind:

docs/docs/concepts/tracing.mdx

@@ -7,4 +7,4 @@ Traces contain individual steps called `runs`. These can be individual calls fro
 tool, or sub-chains.
 Tracing gives you observability inside your chains and agents, and is vital in diagnosing issues.
 
-For a deeper dive, check out [this LangSmith conceptual guide](https://docs.langchain.com/langsmith/observability-quickstart).
+For a deeper dive, check out [this LangSmith conceptual guide](https://docs.smith.langchain.com/concepts/tracing).

docs/docs/concepts/vectorstores.mdx

@@ -9,7 +9,7 @@
 :::
 :::info[Note]
 
-This conceptual overview focuses on text-based indexing and retrieval for simplicity.
+This conceptual overview focuses on text-based indexing and retrieval for simplicity. 
 However, embedding models can be [multi-modal](https://cloud.google.com/vertex-ai/generative-ai/docs/embeddings/get-multimodal-embeddings)
 and vector stores can be used to store and retrieve a variety of data types beyond text.
 :::
@@ -125,7 +125,7 @@ to the documentation of the specific vectorstore you are using to see what simil
 
 Given a similarity metric to measure the distance between the embedded query and any embedded document, we need an algorithm to efficiently search over *all* the embedded documents to find the most similar ones.
 There are various ways to do this. As an example, many vectorstores implement [HNSW (Hierarchical Navigable Small World)](https://www.pinecone.io/learn/series/faiss/hnsw/), a graph-based index structure that allows for efficient similarity search.
-Regardless of the search algorithm used under the hood, the LangChain vectorstore interface has a `similarity_search` method for all integrations.
+Regardless of the search algorithm used under the hood, the LangChain vectorstore interface has a `similarity_search` method for all integrations. 
 This will take the search query, create an embedding, find similar documents, and return them as a list of [Documents](https://python.langchain.com/api_reference/core/documents/langchain_core.documents.base.Document.html).
 
 ```python
@@ -166,7 +166,7 @@ vectorstore.similarity_search(
     k=2,
     filter={"source": "tweet"},
 )
-```
+```  
 
 :::info[Further reading]
 
@@ -179,7 +179,7 @@ vectorstore.similarity_search(
 
 While algorithms like HNSW provide the foundation for efficient similarity search in many cases, additional techniques can be employed to improve search quality and diversity.
 For example, [maximal marginal relevance](https://python.langchain.com/v0.1/docs/modules/model_io/prompts/example_selectors/mmr/) is a re-ranking algorithm used to diversify search results, which is applied after the initial similarity search to ensure a more diverse set of results.
-As a second example, some [vector stores](/docs/integrations/retrievers/pinecone_hybrid_search/) offer built-in [hybrid-search](https://docs.pinecone.io/guides/data/understanding-hybrid-search) to combine keyword and semantic similarity search, which marries the benefits of both approaches.
+As a second example, some [vector stores](/docs/integrations/retrievers/pinecone_hybrid_search/) offer built-in [hybrid-search](https://docs.pinecone.io/guides/data/understanding-hybrid-search) to combine keyword and semantic similarity search, which marries the benefits of both approaches. 
 At the moment, there is no unified way to perform hybrid search using LangChain vectorstores, but it is generally exposed as a keyword argument that is passed in with `similarity_search`.
 See this [how-to guide on hybrid search](/docs/how_to/hybrid/) for more details.
 
@@ -188,4 +188,4 @@ See this [how-to guide on hybrid search](/docs/how_to/hybrid/) for more details.
 | [Hybrid search](/docs/integrations/retrievers/pinecone_hybrid_search/)                                            | When combining keyword-based and semantic similarity. | Hybrid search combines keyword and semantic similarity, marrying the benefits of both approaches. [Paper](https://arxiv.org/abs/2210.11934). |
 | [Maximal Marginal Relevance (MMR)](https://python.langchain.com/api_reference/pinecone/vectorstores/langchain_pinecone.vectorstores.PineconeVectorStore.html#langchain_pinecone.vectorstores.PineconeVectorStore.max_marginal_relevance_search) | When needing to diversify search results.             | MMR attempts to diversify the results of a search to avoid returning similar and redundant documents.                                        |
 
-
+ 

docs/docs/concepts/why_langchain.mdx

@@ -18,7 +18,7 @@ LangChain exposes a standard interface for key components, making it easy to swi
 
 3. **Observability and evaluation:** As applications become more complex, it becomes increasingly difficult to understand what is happening within them.
 Furthermore, the pace of development can become rate-limited by the [paradox of choice](https://en.wikipedia.org/wiki/Paradox_of_choice).
-For example, developers often wonder how to engineer their prompt or which LLM best balances accuracy, latency, and cost.
+For example, developers often wonder how to engineer their prompt or which LLM best balances accuracy, latency, and cost. 
 [Observability](https://en.wikipedia.org/wiki/Observability) and evaluations can help developers monitor their applications and rapidly answer these types of questions with confidence.
 
 
@@ -29,10 +29,10 @@ As an example, all [chat models](/docs/concepts/chat_models/) implement the [Bas
 This provides a standard way to interact with chat models, supporting important but often provider-specific features like [tool calling](/docs/concepts/tool_calling/) and [structured outputs](/docs/concepts/structured_outputs/).
 
 
-### Example: chat models
+### Example: chat models 
 
 Many [model providers](/docs/concepts/chat_models/) support [tool calling](/docs/concepts/tool_calling/), a critical feature for many applications (e.g., [agents](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/)), that allows a developer to request model responses that match a particular schema.
-The APIs for each provider differ.
+The APIs for each provider differ. 
 LangChain's [chat model](/docs/concepts/chat_models/) interface provides a common way to bind [tools](/docs/concepts/tools) to a model in order to support [tool calling](/docs/concepts/tool_calling/):
 
 ```python
@@ -42,7 +42,7 @@ tools = [my_tool]
 model_with_tools = model.bind_tools(tools)
 ```
 
-Similarly, getting models to produce [structured outputs](/docs/concepts/structured_outputs/) is an extremely common use case.
+Similarly, getting models to produce [structured outputs](/docs/concepts/structured_outputs/) is an extremely common use case. 
 Providers support different approaches for this, including [JSON mode or tool calling](https://platform.openai.com/docs/guides/structured-outputs), with different APIs.
 LangChain's [chat model](/docs/concepts/chat_models/) interface provides a common way to produce structured outputs using the `with_structured_output()` method:
 
@@ -62,9 +62,9 @@ The underlying implementation of the retriever depends on the type of data store
 documents = my_retriever.invoke("What is the meaning of life?")
 ```
 
-## Orchestration
+## Orchestration 
 
-While standardization for individual components is useful, we've increasingly seen that developers want to *combine* components into more complex applications.
+While standardization for individual components is useful, we've increasingly seen that developers want to *combine* components into more complex applications. 
 This motivates the need for [orchestration](https://en.wikipedia.org/wiki/Orchestration_(computing)).
 There are several common characteristics of LLM applications that this orchestration layer should support:
 
@@ -75,7 +75,7 @@ There are several common characteristics of LLM applications that this orchestra
 The recommended way to orchestrate components for complex applications is [LangGraph](https://langchain-ai.github.io/langgraph/concepts/high_level/).
 LangGraph is a library that gives developers a high degree of control by expressing the flow of the application as a set of nodes and edges.
 LangGraph comes with built-in support for [persistence](https://langchain-ai.github.io/langgraph/concepts/persistence/), [human-in-the-loop](https://langchain-ai.github.io/langgraph/concepts/human_in_the_loop/), [memory](https://langchain-ai.github.io/langgraph/concepts/memory/), and other features.
-It's particularly well suited for building [agents](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/) or [multi-agent](https://langchain-ai.github.io/langgraph/concepts/multi_agent/) applications.
+It's particularly well suited for building [agents](https://langchain-ai.github.io/langgraph/concepts/agentic_concepts/) or [multi-agent](https://langchain-ai.github.io/langgraph/concepts/multi_agent/) applications. 
 Importantly, individual LangChain components can be used as LangGraph nodes, but you can also use LangGraph **without** using LangChain components.
 
 :::info[Further reading]
@@ -86,8 +86,8 @@ Have a look at our free course, [Introduction to LangGraph](https://academy.lang
 
 ## Observability and evaluation
 
-The pace of AI application development is often rate-limited by high-quality evaluations because there is a paradox of choice.
-Developers often wonder how to engineer their prompt or which LLM best balances accuracy, latency, and cost.
+The pace of AI application development is often rate-limited by high-quality evaluations because there is a paradox of choice. 
+Developers often wonder how to engineer their prompt or which LLM best balances accuracy, latency, and cost. 
 High quality tracing and evaluations can help you rapidly answer these types of questions with confidence.
 [LangSmith](https://docs.smith.langchain.com/) is our platform that supports observability and evaluation for AI applications.
 See our conceptual guides on [evaluations](https://docs.smith.langchain.com/concepts/evaluation) and [tracing](https://docs.smith.langchain.com/concepts/tracing) for more details.

docs/docs/contributing/how_to/code/guidelines.mdx

@@ -3,9 +3,9 @@
 Here are some things to keep in mind for all types of contributions:
 
 - Follow the ["fork and pull request"](https://docs.github.com/en/get-started/exploring-projects-on-github/contributing-to-a-project) workflow.
-- Fill out the checked-in pull request template when opening pull requests. Note related issues.
+- Fill out the checked-in pull request template when opening pull requests. Note related issues and tag relevant maintainers.
 - Ensure your PR passes formatting, linting, and testing checks before requesting a review.
-  - If you would like comments or feedback on your current progress, please open an issue or discussion.
+  - If you would like comments or feedback on your current progress, please open an issue or discussion and tag a maintainer.
   - See the sections on [Testing](setup.mdx#testing) and [Formatting and Linting](setup.mdx#formatting-and-linting) for how to run these checks locally.
 - Backwards compatibility is key. Your changes must not be breaking, except in case of critical bug and security fixes.
 - Look for duplicate PRs or issues that have already been opened before opening a new one.

docs/docs/contributing/how_to/code/index.mdx

@@ -1,4 +1,4 @@
-# Contribute code
+# Contribute Code
 
 If you would like to add a new feature or update an existing one, please read the resources below before getting started:
 

docs/docs/contributing/how_to/code/setup.mdx

@@ -3,20 +3,12 @@
 This guide walks through how to run the repository locally and check in your first code.
 For a [development container](https://containers.dev/), see the [.devcontainer folder](https://github.com/langchain-ai/langchain/tree/master/.devcontainer).
 
-## Dependency management: `uv` and other env/dependency managers
+## Dependency Management: `uv` and other env/dependency managers
 
 This project utilizes [uv](https://docs.astral.sh/uv/) v0.5+ as a dependency manager.
 
 Install `uv`: **[documentation on how to install it](https://docs.astral.sh/uv/getting-started/installation/)**.
 
-### Windows Users
-
-If you're on Windows and don't have `make` installed, you can install it via:
-- **Option 1**: Install via [Chocolatey](https://chocolatey.org/): `choco install make`
-- **Option 2**: Install via [Scoop](https://scoop.sh/): `scoop install make`
-- **Option 3**: Use [Windows Subsystem for Linux (WSL)](https://docs.microsoft.com/en-us/windows/wsl/)
-- **Option 4**: Use the direct `uv` commands shown in the sections below
-
 ## Different packages
 
 This repository contains multiple packages:
@@ -45,7 +37,7 @@ For this quickstart, start with `langchain`:
 cd libs/langchain
 ```
 
-## Local development dependencies
+## Local Development Dependencies
 
 Install development requirements (for running langchain, running examples, linting, formatting, tests, and coverage):
 
@@ -56,11 +48,7 @@ uv sync
 Then verify dependency installation:
 
 ```bash
-# If you have `make` installed:
 make test
-
-# If you don't have `make` (Windows alternative):
-uv run --group test pytest -n auto --disable-socket --allow-unix-socket tests/unit_tests
 ```
 
 ## Testing
@@ -73,11 +61,13 @@ If you add new logic, please add a unit test.
 To run unit tests:
 
 ```bash
-# If you have `make` installed:
 make test
+```
 
-# If you don't have make (Windows alternative):
-uv run --group test pytest -n auto --disable-socket --allow-unix-socket tests/unit_tests
+To run unit tests in Docker:
+
+```bash
+make docker_tests
 ```
 
 There are also [integration tests and code-coverage](../testing.mdx) available.
@@ -88,56 +78,34 @@ If you are only developing `langchain_core`, you can simply install the dependen
 
 ```bash
 cd libs/core
-
-# If you have `make` installed:
 make test
-
-# If you don't have `make` (Windows alternative):
-uv run --group test pytest -n auto --disable-socket --allow-unix-socket tests/unit_tests
 ```
 
-## Formatting and linting
+## Formatting and Linting
 
 Run these locally before submitting a PR; the CI system will check also.
 
-### Code formatting
+### Code Formatting
 
 Formatting for this project is done via [ruff](https://docs.astral.sh/ruff/rules/).
 
 To run formatting for docs, cookbook and templates:
 
 ```bash
-# If you have `make` installed:
 make format
-
-# If you don't have make (Windows alternative):
-uv run --all-groups ruff format .
-uv run --all-groups ruff check --fix .
 ```
 
 To run formatting for a library, run the same command from the relevant library directory:
 
 ```bash
 cd libs/{LIBRARY}
-
-# If you have `make` installed:
 make format
-
-# If you don't have make (Windows alternative):
-uv run --all-groups ruff format .
-uv run --all-groups ruff check --fix .
 ```
 
 Additionally, you can run the formatter only on the files that have been modified in your current branch as compared to the master branch using the format_diff command:
 
 ```bash
-# If you have `make` installed:
 make format_diff
-
-# If you don't have `make` (Windows alternative):
-# First, get the list of modified files:
-git diff --relative=libs/langchain --name-only --diff-filter=d master | grep -E '\.py$$|\.ipynb$$' | xargs uv run --all-groups ruff format
-git diff --relative=libs/langchain --name-only --diff-filter=d master | grep -E '\.py$$|\.ipynb$$' | xargs uv run --all-groups ruff check --fix
 ```
 
 This is especially useful when you have made changes to a subset of the project and want to ensure your changes are properly formatted without affecting the rest of the codebase.
@@ -149,40 +117,20 @@ Linting for this project is done via a combination of [ruff](https://docs.astral
 To run linting for docs, cookbook and templates:
 
 ```bash
-# If you have `make` installed:
 make lint
-
-# If you don't have `make` (Windows alternative):
-uv run --all-groups ruff check .
-uv run --all-groups ruff format . --diff
-uv run --all-groups mypy . --cache-dir .mypy_cache
 ```
 
 To run linting for a library, run the same command from the relevant library directory:
 
 ```bash
 cd libs/{LIBRARY}
-
-# If you have `make` installed:
 make lint
-
-# If you don't have `make` (Windows alternative):
-uv run --all-groups ruff check .
-uv run --all-groups ruff format . --diff
-uv run --all-groups mypy . --cache-dir .mypy_cache
 ```
 
 In addition, you can run the linter only on the files that have been modified in your current branch as compared to the master branch using the lint_diff command:
 
 ```bash
-# If you have `make` installed:
 make lint_diff
-
-# If you don't have `make` (Windows alternative):
-# First, get the list of modified files:
-git diff --relative=libs/langchain --name-only --diff-filter=d master | grep -E '\.py$$|\.ipynb$$' | xargs uv run --all-groups ruff check
-git diff --relative=libs/langchain --name-only --diff-filter=d master | grep -E '\.py$$|\.ipynb$$' | xargs uv run --all-groups ruff format --diff
-git diff --relative=libs/langchain --name-only --diff-filter=d master | grep -E '\.py$$|\.ipynb$$' | xargs uv run --all-groups mypy --cache-dir .mypy_cache
 ```
 
 This can be very helpful when you've made changes to only certain parts of the project and want to ensure your changes meet the linting standards without having to check the entire codebase.
@@ -197,21 +145,13 @@ Note that `codespell` finds common typos, so it could have false-positive (corre
 To check spelling for this project:
 
 ```bash
-# If you have `make` installed:
 make spell_check
-
-# If you don't have `make` (Windows alternative):
-uv run --all-groups codespell --toml pyproject.toml
 ```
 
 To fix spelling in place:
 
 ```bash
-# If you have `make` installed:
 make spell_fix
-
-# If you don't have `make` (Windows alternative):
-uv run --all-groups codespell --toml pyproject.toml -w
 ```
 
 If codespell is incorrectly flagging a word, you can skip spellcheck for that word by adding it to the codespell config in the `pyproject.toml` file.
@@ -223,50 +163,7 @@ If codespell is incorrectly flagging a word, you can skip spellcheck for that wo
 ignore-words-list = 'momento,collison,ned,foor,reworkd,parth,whats,aapply,mysogyny,unsecure'
 ```
 
-### Pre-commit
-
-We use [pre-commit](https://pre-commit.com/) to ensure commits are formatted/linted.
-
-#### Installing Pre-commit
-
-First, install pre-commit:
-
-```bash
-# Option 1: Using uv (recommended)
-uv tool install pre-commit
-
-# Option 2: Using Homebrew (globally for macOS/Linux)
-brew install pre-commit
-
-# Option 3: Using pip
-pip install pre-commit
-```
-
-Then install the git hook scripts:
-
-```bash
-pre-commit install
-```
-
-#### How Pre-commit Works
-
-Once installed, pre-commit will automatically run on every `git commit`. Hooks are specified in `.pre-commit-config.yaml` and will:
-
-- Format code using `ruff` for the specific library/package you're modifying
-- Only run on files that have changed
-- Prevent commits if formatting fails
-
-#### Skipping Pre-commit
-
-In exceptional cases, you can skip pre-commit hooks with:
-
-```bash
-git commit --no-verify
-```
-
-However, this is discouraged as the CI system will still enforce the same formatting rules.
-
-## Working with optional dependencies
+## Working with Optional Dependencies
 
 `langchain`, `langchain-community`, and `langchain-experimental` rely on optional dependencies to keep these packages lightweight.
 

docs/docs/contributing/how_to/documentation/index.mdx

@@ -1,6 +1,6 @@
-# Contribute documentation
+# Contribute Documentation
 
-Documentation is a vital part of LangChain. We welcome both new documentation for new features and
+Documentation is a vital part of LangChain. We welcome both new documentation for new features and 
 community improvements to our current documentation. Please read the resources below before getting started:
 
 - [Documentation style guide](style_guide.mdx)

docs/docs/contributing/how_to/documentation/setup.mdx

@@ -12,11 +12,12 @@ It covers a wide array of topics, including tutorials, use cases, integrations,
 and more, offering extensive guidance on building with LangChain.
 The content for this documentation lives in the `/docs` directory of the monorepo.
 2. In-code Documentation: This is documentation of the codebase itself, which is also
-used to generate the externally facing [API Reference](https://python.langchain.com/api_reference/).
+used to generate the externally facing [API Reference](https://python.langchain.com/api_reference/langchain/index.html).
 The content for the API reference is autogenerated by scanning the docstrings in the codebase. For this reason we ask that
 developers document their code well.
 
-The API Reference is largely autogenerated by [sphinx](https://www.sphinx-doc.org/en/master/) from the code.
+The `API Reference` is largely autogenerated by [sphinx](https://www.sphinx-doc.org/en/master/)
+from the code and is hosted by [Read the Docs](https://readthedocs.org/).
 
 We appreciate all contributions to the documentation, whether it be fixing a typo,
 adding a new tutorial or example and whether it be in the main documentation or the API Reference.
@@ -24,7 +25,7 @@ adding a new tutorial or example and whether it be in the main documentation or
 Similar to linting, we recognize documentation can be annoying. If you do not want
 to do it, please contact a project maintainer, and they can help you with it. We do not want this to be a blocker for good code getting contributed.
 
-## 📜 Main documentation
+## 📜 Main Documentation
 
 The content for the main documentation is located in the `/docs` directory of the monorepo.
 
@@ -41,7 +42,7 @@ After modifying the documentation:
 3. Make a pull request with the changes.
 4. You can preview and verify that the changes are what you wanted by clicking the `View deployment` or `Visit Preview` buttons on the pull request `Conversation` page. This will take you to a preview of the documentation changes.
 
-## ⚒️ Linting and building documentation locally
+## ⚒️ Linting and Building Documentation Locally
 
 After writing up the documentation, you may want to lint and build the documentation
 locally to ensure that it looks good and is free of errors.
@@ -56,44 +57,20 @@ The code that builds the documentation is located in the `/docs` directory of th
 
 In the following commands, the prefix `api_` indicates that those are operations for the API Reference.
 
-You can build the documentation as outlined below:
+Before building the documentation, it is always a good idea to clean the build directory:
+
+```bash
+make docs_clean
+make api_docs_clean
+```
+
+Next, you can build the documentation as outlined below:
 
 ```bash
 make docs_build
 make api_docs_build
 ```
 
-### Viewing documentation locally
-
-After building the main documentation, you can view it locally by starting a development server:
-
-```bash
-# For main documentation (after running `make docs_build`)
-cd docs && make start
-```
-
-This will start a development server where you can view the documentation in your browser. The exact url will be shown to you during the start process. The server will automatically reload when you make changes to the documentation files under the `build/` directory (e.g. for temporary tests - changes you wish to persist should be put under `docs/docs/`).
-
-:::tip
-
-You can specify a different port by setting the `PORT` environment variable:
-
-```bash
-cd docs && PORT=3000 make start
-```
-
-:::
-
-The API Reference documentation is built as static HTML files and will be automatically opened directly in your browser.
-
-You can also view the API Reference for a specific package by specifying the package name and installing the package if necessary dependencies:
-
-```bash
-# Opens the API Reference for the `ollama` package in your default browser
-uv pip install -e libs/partners/ollama
-make api_docs_quick_preview API_PKG=ollama
-```
-
 :::tip
 
 The `make api_docs_build` command takes a long time. If you're making cosmetic changes to the API docs and want to see how they look, use:
@@ -102,28 +79,18 @@ The `make api_docs_build` command takes a long time. If you're making cosmetic c
 make api_docs_quick_preview
 ```
 
-which will just build a small subset of the API reference (the `text-splitters` package).
+which will just build a small subset of the API reference.
 
 :::
 
-Finally, run the link checker from the project root to ensure all links are valid:
+Finally, run the link checker to ensure all links are valid:
 
 ```bash
 make docs_linkcheck
 make api_docs_linkcheck
 ```
 
-To clean up the documentation build artifacts, you can run:
-
-```bash
-make clean
-
-# Or to clean specific documentation artifacts
-make docs_clean
-make api_docs_clean
-```
-
-### Formatting and linting
+### Linting and Formatting
 
 The Main Documentation is linted from the **monorepo root**. To lint the main documentation, run the following from there:
 
@@ -137,9 +104,9 @@ If you have formatting-related errors, you can fix them automatically with:
 make format
 ```
 
-## ⌨️ In-code documentation
+## ⌨️ In-code Documentation
 
-The in-code documentation is largely autogenerated by [sphinx](https://www.sphinx-doc.org/en/master/) from the code following [reStructuredText](https://www.sphinx-doc.org/en/master/usage/restructuredtext/basics.html).
+The in-code documentation is largely autogenerated by [sphinx](https://www.sphinx-doc.org/en/master/) from the code and is hosted by [Read the Docs](https://readthedocs.org/).
 
 For the API reference to be useful, the codebase must be well-documented. This means that all functions, classes, and methods should have a docstring that explains what they do, what the arguments are, and what the return value is. This is a good practice in general, but it is especially important for LangChain because the API reference is the primary resource for developers to understand how to use the codebase.
 
@@ -174,16 +141,16 @@ def my_function(arg1: int, arg2: str) -> float:
     return 3.14
 ```
 
-### Formatting and linting
+### Linting and Formatting
 
 The in-code documentation is linted from the directories belonging to the packages
 being documented.
 
-For example, if you're working on the `langchain-ollama` package, you would change
-the working directory to the the package directory:
+For example, if you're working on the `langchain-community` package, you would change
+the working directory to the `langchain-community` directory:
 
 ```bash
-cd [root]/libs/partners/ollama
+cd [root]/libs/langchain-community
 ```
 
 Then you can run the following commands to lint and format the in-code documentation:
@@ -193,9 +160,9 @@ make format
 make lint
 ```
 
-## Verify documentation changes
+## Verify Documentation Changes
 
 After pushing documentation changes to the repository, you can preview and verify that the changes are
 what you wanted by clicking the `View deployment` or `Visit Preview` buttons on the pull request `Conversation` page.
 This will take you to a preview of the documentation changes.
-This preview is created by [Vercel](https://vercel.com/docs/getting-started-with-vercel).
+This preview is created by [Vercel](https://vercel.com/docs/getting-started-with-vercel).

docs/docs/contributing/how_to/documentation/style_guide.mdx

@@ -2,7 +2,7 @@
 sidebar_class_name: "hidden"
 ---
 
-# Documentation style guide
+# Documentation Style Guide
 
 As LangChain continues to grow, the amount of documentation required to cover the various concepts and integrations continues to grow too.
 This page provides guidelines for anyone writing documentation for LangChain and outlines some of our philosophies around
@@ -35,7 +35,7 @@ Some examples include:
 - [Build a Retrieval Augmented Generation (RAG) App](/docs/tutorials/rag/)
 
 A good structural rule of thumb is to follow the structure of this [example from Numpy](https://numpy.org/numpy-tutorials/content/tutorial-svd.html).
-
+  
 Here are some high-level tips on writing a good tutorial:
 
 - Focus on guiding the user to get something done, but keep in mind the end-goal is more to impart principles than to create a perfect production system.
@@ -49,7 +49,7 @@ Here are some high-level tips on writing a good tutorial:
 - The first time you mention a LangChain concept, use its full name (e.g. "LangChain Expression Language (LCEL)"), and link to its conceptual/other documentation page.
   - It's also helpful to add a prerequisite callout that links to any pages with necessary background information.
 - End with a recap/next steps section summarizing what the tutorial covered and future reading, such as related how-to guides.
-
+  
 ### How-to guides
 
 A how-to guide, as the name implies, demonstrates how to do something discrete and specific.
@@ -79,7 +79,7 @@ Here are some high-level tips on writing a good how-to guide:
 
 ### Conceptual guide
 
-LangChain's conceptual guides fall under the **Explanation** quadrant of Diataxis. These guides should cover LangChain terms and concepts
+LangChain's conceptual guide falls under the **Explanation** quadrant of Diataxis. These guides should cover LangChain terms and concepts
 in a more abstract way than how-to guides or tutorials, targeting curious users interested in
 gaining a deeper understanding and insights of the framework. Try to avoid excessively large code examples as the primary goal is to
 provide perspective to the user rather than to finish a practical project. These guides should cover **why** things work the way they do.
@@ -105,7 +105,7 @@ Here are some high-level tips on writing a good conceptual guide:
 ### References
 
 References contain detailed, low-level information that describes exactly what functionality exists and how to use it.
-In LangChain, these are mainly our API reference pages, which are populated from docstrings within code.
+In LangChain, this is mainly our API reference pages, which are populated from docstrings within code.
 References pages are generally not read end-to-end, but are consulted as necessary when a user needs to know
 how to use something specific.
 
@@ -119,7 +119,7 @@ but here are some high-level tips on writing a good docstring:
 - Be concise
 - Discuss special cases and deviations from a user's expectations
 - Go into detail on required inputs and outputs
-- Light details on when one might use the feature are fine, but in-depth details belong in other sections
+- Light details on when one might use the feature are fine, but in-depth details belong in other sections.
 
 Each category serves a distinct purpose and requires a specific approach to writing and structuring the content.
 
@@ -127,17 +127,17 @@ Each category serves a distinct purpose and requires a specific approach to writ
 
 Here are some other guidelines you should think about when writing and organizing documentation.
 
-We generally do not merge new tutorials from outside contributors without an acute need.
+We generally do not merge new tutorials from outside contributors without an actue need.
 We welcome updates as well as new integration docs, how-tos, and references.
 
 ### Avoid duplication
 
 Multiple pages that cover the same material in depth are difficult to maintain and cause confusion. There should
-be only one (very rarely two) canonical pages for a given concept or feature. Instead, you should link to other guides.
+be only one (very rarely two), canonical pages for a given concept or feature. Instead, you should link to other guides.
 
 ### Link to other sections
 
-Because sections of the docs do not exist in a vacuum, it is important to link to other sections frequently
+Because sections of the docs do not exist in a vacuum, it is important to link to other sections frequently,
 to allow a developer to learn more about an unfamiliar topic within the flow of reading.
 
 This includes linking to the API references and conceptual sections!
@@ -158,5 +158,3 @@ Be concise, including in code samples.
 - Use bullet points and numbered lists to break down information into easily digestible chunks
 - Use tables (especially for **Reference** sections) and diagrams often to present information visually
 - Include the table of contents for longer documentation pages to help readers navigate the content, but hide it for shorter pages
-
-Next, see the [documentation setup guide](setup.mdx) to get started with writing documentation for LangChain.

docs/docs/contributing/how_to/index.mdx

@@ -1,4 +1,4 @@
-# How-to guides
+# How-to Guides
 
 - [**Documentation**](documentation/index.mdx): Help improve our docs, including this one!
 - [**Code**](code/index.mdx): Help us write code, fix bugs, or improve our infrastructure.

docs/docs/contributing/how_to/integrations/community.mdx

@@ -15,7 +15,7 @@ guide linked without much discussion.
 
 The `langchain-community` package is in `libs/community`.
 
-It can be installed with `pip install langchain-community`, and exported members can be imported with code like
+It can be installed with `pip install langchain-community`, and exported members can be imported with code like 
 
 ```python
 from langchain_community.chat_models import ChatParrotLink
@@ -23,7 +23,7 @@ from langchain_community.llms import ParrotLinkLLM
 from langchain_community.vectorstores import ParrotLinkVectorStore
 ```
 
-The `community` package relies on manually-installed dependent packages, so you will see errors
+The `community` package relies on manually-installed dependent packages, so you will see errors 
 if you try to import a package that is not installed. In our fake example, if you tried to import `ParrotLinkLLM` without installing `parrot-link-sdk`, you will see an `ImportError` telling you to install it when trying to use it.
 
 Let's say we wanted to implement a chat model for Parrot Link AI. We would create a new file in `libs/community/langchain_community/chat_models/parrot_link.py` with the following code:

docs/docs/contributing/how_to/integrations/from_template.mdx

@@ -14,8 +14,8 @@ First, duplicate this template repository: https://github.com/langchain-ai/integ
 In this guide, we will create a `libs/langchain-parrot-link` folder, simulating the creation
 of a partner package for a fake company, "Parrot Link AI".
 
-A package is
-installed by users with `pip install langchain-{partner}`, and the package members
+A package is 
+installed by users with `pip install langchain-{partner}`, and the package members 
 can be imported with code like:
 
 ```python
@@ -93,11 +93,11 @@ to the relevant `docs/docs/integrations` directory in the monorepo root.
 
 ## (If Necessary) Deprecate community integration
 
-Note: this is only necessary if you're migrating an existing community integration into
-a partner package. If the component you're integrating is net-new to LangChain (i.e.
+Note: this is only necessary if you're migrating an existing community integration into 
+a partner package. If the component you're integrating is net-new to LangChain (i.e. 
 not already in the `community` package), you can skip this step.
 
-Let's pretend we migrated our `ChatParrotLink` chat model from the community package to
+Let's pretend we migrated our `ChatParrotLink` chat model from the community package to 
 the partner package. We would need to deprecate the old model in the community package.
 
 We would do that by adding a `@deprecated` decorator to the old model as follows, in
@@ -116,8 +116,8 @@ After our change, it would look like this:
 from langchain_core._api.deprecation import deprecated
 
 @deprecated(
-    since="0.0.<next community version>",
-    removal="1.0.0",
+    since="0.0.<next community version>", 
+    removal="1.0.0", 
     alternative_import="langchain_parrot_link.ChatParrotLink"
 )
 class ChatParrotLink(BaseChatModel):

docs/docs/contributing/how_to/integrations/index.mdx

@@ -3,7 +3,7 @@ pagination_prev: null
 pagination_next: contributing/how_to/integrations/package
 ---
 
-# Contribute integrations
+# Contribute Integrations
 
 Integrations are a core component of LangChain.
 LangChain provides standard interfaces for several different components (language models, vector stores, etc) that are crucial when building LLM applications.
@@ -16,7 +16,7 @@ LangChain provides standard interfaces for several different components (languag
 - **Best Practices:** Through their standard interface, LangChain components encourage and facilitate best practices (streaming, async, etc)
 
 
-## Components to integrate
+## Components to Integrate
 
 :::info
 
@@ -71,7 +71,7 @@ In order to contribute an integration, you should follow these steps:
 5. [Optional] Open and merge a PR to add documentation for your integration to the official LangChain docs.
 6. [Optional] Engage with the LangChain team for joint co-marketing ([see below](#co-marketing)).
 
-## Co-marketing
+## Co-Marketing
 
 With over 20 million monthly downloads, LangChain has a large audience of developers
 building LLM applications. Beyond just listing integrations, we aim to highlight
@@ -87,5 +87,5 @@ Here are some heuristics for types of content we are excited to promote:
 - **End-to-end applications:** End-to-end applications are great resources for developers looking to build. We prefer to highlight applications that are more complex/agentic in nature, and that use [LangGraph](https://github.com/langchain-ai/langgraph) as the orchestration framework. We get particularly excited about anything involving long-term memory, human-in-the-loop interaction patterns, or multi-agent architectures.
 - **Research:** We love highlighting novel research! Whether it is research built on top of LangChain or that integrates with it.
 
-## Further reading
+## Further Reading
 To get started, let's learn [how to implement an integration package](/docs/contributing/how_to/integrations/package/) for LangChain.

docs/docs/contributing/how_to/integrations/package.mdx

@@ -4,7 +4,7 @@ pagination_prev: contributing/how_to/integrations/index
 ---
 # How to implement an integration package
 
-This guide walks through the process of implementing a LangChain integration
+This guide walks through the process of implementing a LangChain integration 
 package.
 
 Integration packages are just Python packages that can be installed with `pip install <your-package>`,
@@ -14,11 +14,11 @@ We will cover:
 
 1. (Optional) How to bootstrap a new integration package
 2. How to implement components, such as [chat models](/docs/concepts/chat_models/) and [vector stores](/docs/concepts/vectorstores/), that adhere
-to the LangChain interface;
+to the LangChain interface;  
 
 ## (Optional) bootstrapping a new integration package
 
-In this section, we will outline 2 options for bootstrapping a new integration package,
+In this section, we will outline 2 options for bootstrapping a new integration package, 
 and you're welcome to use other tools if you prefer!
 
 1. **langchain-cli**: This is a command-line tool that can be used to bootstrap a new integration package with a template for LangChain components and Poetry for dependency management.
@@ -132,7 +132,7 @@ We will also add some `test` dependencies in a separate poetry dependency group.
 you are not using Poetry, we recommend adding these in a way that won't package them
 with your published package, or just installing them separately when you run tests.
 
-`langchain-tests` will provide the [standard tests](../standard_tests) we will use later.
+`langchain-tests` will provide the [standard tests](../standard_tests) we will use later. 
 We recommended pinning these to the latest version: <img src="https://img.shields.io/pypi/v/langchain-tests" style={{position:"relative",top:4,left:3}} />
 
 Note: Replace `<latest_version>` with the latest version of `langchain-tests` below.
@@ -168,8 +168,8 @@ langchain-parrot-link/
 └── README.md
 ```
 
-All of these files should already exist from step 1, except for
-`chat_models.py` and `test_chat_models.py`! We will implement `test_chat_models.py`
+All of these files should already exist from step 1, except for 
+`chat_models.py` and `test_chat_models.py`! We will implement `test_chat_models.py` 
 later, following the [standard tests](../standard_tests) guide.
 
 For `chat_models.py`, simply paste the contents of the chat model implementation
@@ -202,7 +202,7 @@ import CodeBlock from '@theme/CodeBlock';
 <Tabs>
 
     <TabItem value="chat_models" label="Chat models">
-
+        
         Refer to the [Custom Chat Model Guide](/docs/how_to/custom_chat_model) guide for
         detail on a starter chat model [implementation](/docs/how_to/custom_chat_model/#implementation).
 
@@ -244,7 +244,7 @@ import ChatModelSource from '../../../../src/theme/integration_template/integrat
         base class. This interface consists of methods for writing, deleting and searching
         for documents in the vector store.
 
-        `VectorStore` supports a variety of synchronous and asynchronous search types (e.g.,
+        `VectorStore` supports a variety of synchronous and asynchronous search types (e.g., 
         nearest-neighbor or maximum marginal relevance), as well as interfaces for adding
         documents to the store. See the [API Reference](https://python.langchain.com/api_reference/core/vectorstores/langchain_core.vectorstores.base.VectorStore.html)
         for all supported methods. The required methods are tabulated below:
@@ -331,7 +331,7 @@ or parameters to call the tool with.
 2. To take a "tool call" as generated above, and take some action and return a response
 that can be passed back to the chat model as a ToolMessage.
 
-The `Tools` class must inherit from the [BaseTool](https://python.langchain.com/api_reference/core/tools/langchain_core.tools.base.BaseTool.html#langchain_core.tools.base.BaseTool) base class. This interface has 3 properties and 2 methods that should be implemented in a
+The `Tools` class must inherit from the [BaseTool](https://python.langchain.com/api_reference/core/tools/langchain_core.tools.base.BaseTool.html#langchain_core.tools.base.BaseTool) base class. This interface has 3 properties and 2 methods that should be implemented in a 
 subclass.
 
 | Method/Property         | Description                                          |
@@ -355,10 +355,10 @@ important for the initial user experience of the tool.
 arguments. This is used to validate the input arguments to the tool, and to provide
 a schema for the LLM to fill out when calling the tool. Similar to the `name` and
 `description` of the overall Tool class, the fields' names (the variable name) and
-description (part of `Field(..., description="description")`) are passed to the LLM,
+description (part of `Field(..., description="description")`) are passed to the LLM, 
 and the values in these fields should be concise and LLM-usable.
 
-### Run methods
+### Run Methods
 
 `_run` is the main method that should be implemented in the subclass. This method
 takes in the arguments from `args_schema` and runs the tool, returning a string
@@ -469,6 +469,6 @@ import RetrieverSource from '/src/theme/integration_template/integration_templat
 
 ---
 
-## Next steps
+## Next Steps
 
 Now that you've implemented your package, you can move on to [testing your integration](../standard_tests) for your integration and successfully run them.