Contributing to code

Code contributions are always welcome! Whether you’re fixing bugs, adding features, or improving performance, your contributions help deliver a better developer experience for thousands of developers.

Getting started

Before submitting large new features or refactors, please first discuss your ideas in the forum. This ensures alignment with project goals and prevents duplicate work.This does not apply to bugfixes or small improvements, which you can contribute directly via pull requests. See the quickstart guide below.

Quick fix: submit a bugfix

For simple bugfixes, you can get started immediately:

Reproduce the issue

Create a minimal test case that demonstrates the bug. Maintainers and other contributors should be able to run this test and see the failure without additional setup or modification

Fork the repository

Fork the LangChain or LangGraph repo to your personal GitHub account

Clone and setup

git clone https://github.com/your-username/name-of-forked-repo.git

# For instance, for LangChain:
git clone https://github.com/parrot123/langchainjs.git

# For LangGraph:
git clone https://github.com/parrot123/langgraphjs.git

# Inside your repo, install dependencies
pnpm install
# Create a build for all packages to resolve workspace dependencies
pnpm build

Create a branch

Create a new branch for your fix. This helps keep your changes organized and makes it easier to submit a pull request later.

git checkout -b your-username/short-bugfix-name

Write failing tests

Add unit tests that will fail without your fix. This allows us to verify the bug is resolved and prevents regressions

Make your changes

Fix the bug while following our code quality standards. Make the minimal change necessary to resolve the issue

Run build

Run the build command to ensure the package still builds properly

pnpm build
# or build a specific workspace package
pnpm --filter @langchain/core build

Verify the fix

Ensure that tests pass and no regressions are introduced. Ensure all tests pass locally before submitting your PR

pnpm lint
pnpm test

# For bugfixes involving integrations, also run:
pnpm test:int

# Or run tests in a specific workspace package
cd libs/langchain-core
pnpm test
pnpm lint

# Or run tests for a specific package from the root of the repo
pnpm --filter @langchain/core test
pnpm --filter @langchain/core lint

Document the change

Update docstrings if behavior changes, add comments for complex logic

Submit a pull request

Follow the PR template provided. If applicable, reference the issue you’re fixing using a closing keyword (e.g. Fixes #ISSUE_NUMBER) so that the issue is automatically closed when your PR is merged.

Full development setup

For ongoing development or larger contributions:

Review our contribution guidelines for features, bugfixes, and integrations
Set up your environment following our setup guide below
Understand the repository structure and package organization
Learn our development workflow including testing and linting

Contribution guidelines

Before you start contributing to LangChain, take a moment to think about why you want to. If your only goal is to add a “first contribution” to your resume (or if you’re just looking for a quick win) you might be better off doing a boot-camp or an online tutorial. Contributing to open source projects takes time and effort, but it can also help you become a better developer and learn new skills. However, it’s important to know that it might be harder and slower than following a training course. That said, contributing to open source is worth it if you’re willing to take the time to do things well.

Backwards compatibility

Breaking changes to public APIs are not allowed except for critical security fixes.See our versioning policy for details on major version releases.

Maintain compatibility via:

Stable interfaces

Always preserve:

Function signatures and parameter names
Class interfaces and method names
Return value structure and types
Import paths for public APIs

Safe changes

Acceptable modifications:

Adding new optional parameters/type parameters
Adding new methods to classes
Improving performance without changing behavior
Adding new modules or functions

Before making changes

Would this break existing user code?
Check if your target is public
Are there existing usage patterns in tests?

New features

We aim to keep the bar high for new features. We generally don’t accept new core abstractions from outside contributors without an existing issue that demonstrates an acute need for them. This also applies to changes to infra and dependencies. In general, feature contribution requirements include:

Design discussion

Open an issue describing:

The problem you’re solving
Proposed API design
Expected usage patterns

Implementation

Follow existing code patterns
Include comprehensive tests and documentation
Consider security implications

Integration considerations

How does this interact with existing features?
Are there performance implications?
Does this introduce new dependencies?

We will reject features that are likely to lead to security vulnerabilities or reports.

Security guidelines

Security is paramount. Never introduce vulnerabilities or unsafe patterns.

Security checklist:

Input validation

Validate and sanitize all user inputs
Properly escape data in templates and queries
Never use eval(), as this can lead to arbitrary code execution vulnerabilities

Error handling

Use specific exception types
Don’t expose sensitive information in error messages
Implement proper resource cleanup

Dependencies

Avoid adding hard dependencies
Keep optional dependencies minimal
Review third-party packages for security issues

Development environment

Our JS/TS projects uses pnpm for dependency management. Make sure you have the latest version installed, or run corepack enable (on Node 24+) to setup the required pnpm version.

Once you’ve reviewed the contribution guidelines, set up a development environment for the package(s) you’re working on.

LangChain
LangGraph

Core abstractions

For changes to langchain-core:

pnpm install
# Run tests for a package from the package directory
cd libs/langchain-core
pnpm test

# Or run tests for a package from the root of the repo
pnpm --filter @langchain/core test

Main package

For changes to langchain:

pnpm install
pnpm --filter langchain test  # Ensure tests pass before starting development

Provider packages

For changes to partner integrations:

pnpm install
pnpm --filter @langchain/{provider} test  # Ensure tests pass before starting development

Community packages

For changes to community integrations:

pnpm install
pnpm --filter @langchain/community test  # Ensure tests pass before starting development

Repository structure

LangChain
LangGraph

LangChain is organized as a monorepo with multiple packages:

Core packages

langchain (located in libs/langchain/): Main package with chains, agents, and retrieval logic
@langchain/core (located in libs/langchain-core/): Base interfaces and core abstractions

Partner packages

Located in libs/providers/, these are independently versioned packages for specific integrations. For example:

@langchain/openai: OpenAI integrations
@langchain/anthropic: Anthropic integrations
@langchain/google-genai: Google Generative AI integrations

Supporting packages

@langchain/textsplitters: Text splitting utilities
@langchain/standard-tests: Standard test suites for integrations
langchain-community: Community maintained integrations

Development workflow

Testing requirements

Directories are relative to the package you’re working in.

Every code change must include comprehensive tests.

Unit tests

Location: src/tests/FILENAME_BEING_TESTED.test.ts Requirements:

No network calls allowed
Test all code paths including edge cases
Use mocks for external dependencies

# Run the entire test suite
pnpm test

# Or run a specific test file
pnpm test src/tests/FILENAME_BEING_TESTED.test.ts

# Or run a specific test function
pnpm test -t "the test that should be run"

Integration tests

Location: src/tests/FILENAME_BEING_TESTED.int.test.ts Integration tests require access to external services/ provider APIs (which can cost money) and therefore are not run by default. Not every code change will require an integration test, but keep in mind that we’ll require/ run integration tests separately as apart of our review process. Requirements:

Test real integrations with external services
Use environment variables for API keys
Skip gracefully if credentials unavailable

pnpm test:int

Code quality standards

Contributions must adhere to the following quality requirements:

Type hints
Documentation
Code style

Required: Complete types for all functions

function processDocuments(
    docs: Document[],
    processor: DocumentProcessor,
    batchSize: number = 100
): ProcessingResult {
    // ...
}

Testing and validation

Running tests locally

Before submitting your PR, ensure you have completed the following steps. Note that the requirements differ slightly between LangChain and LangGraph.

LangChain
LangGraph

Unit tests

pnpm test

All unit tests must pass

Integration tests

pnpm test:int

(Run if your changes affect integrations)

Formatting

pnpm format
pnpm lint

Code must pass all style checks

PR submission

Push your branch and open a pull request. Follow the provided form template. Note related issues using a closing keyword. After submitting, wait, and check to ensure the CI checks pass. If any checks fail, address the issues promptly - maintainers may close PRs that do not pass CI within a reasonable timeframe.

Test writing guidelines

In order to write effective tests, there’s a few good practices to follow:

Encapsulate the test in a describe block that describes the component being tested
Use natural language to describe the test name
Be exhaustive with assertions
Only use snapshots for reasonably sized data objects

Unit tests
Integration tests
Mock usage

describe("DocumentProcessor", () => {
    it("Should handle empty document list", () => {
        const processor = new DocumentProcessor();
        const result = processor.process([]);

        expect(result.success).toBe(true);
        expect(result.processedCount).toBe(0);
        expect(result.errors).toHaveLength(0);
    });
});

Getting help

Our goal is to have the most accessible developer setup possible. Should you experience any difficulty getting setup, please ask in the community slack or open a forum post.

You’re now ready to contribute high-quality code to LangChain!

Edit the source of this page on GitHub.

Connect these docs programmatically to Claude, VSCode, and more via MCP for real-time answers.

Contribute

Integrations

Getting started

Quick fix: submit a bugfix

Full development setup

Contribution guidelines

Backwards compatibility

New features

Security guidelines

Development environment

Repository structure

Development workflow

Testing requirements

Unit tests

Integration tests

Code quality standards

Testing and validation

Running tests locally

Test writing guidelines

Getting help

Contribute

Integrations

​Getting started

​Quick fix: submit a bugfix

​Full development setup

​Contribution guidelines

​Backwards compatibility

​New features

​Security guidelines

​Development environment

​Repository structure

​Development workflow

​Testing requirements

​Unit tests

​Integration tests

​Code quality standards

​Testing and validation

​Running tests locally

​Test writing guidelines

​Getting help

Getting started

Quick fix: submit a bugfix

Full development setup

Contribution guidelines

Backwards compatibility

New features

Security guidelines

Development environment

Repository structure

Development workflow

Testing requirements

Unit tests

Integration tests

Code quality standards

Testing and validation

Running tests locally

Test writing guidelines

Getting help