Skip to main content

Setup

This guide walks through how to run the repository locally and check in your first code. For a development container, see the .devcontainer folder.

Dependency Management: Poetry and other env/dependency managers​

This project utilizes Poetry v1.7.1+ as a dependency manager.

❗Note: Before installing Poetry, if you use Conda, create and activate a new Conda env (e.g. conda create -n langchain python=3.9)

Install Poetry: documentation on how to install it.

❗Note: If you use Conda or Pyenv as your environment/package manager, after installing Poetry, tell Poetry to use the virtualenv python environment (poetry config virtualenvs.prefer-active-python true)

Different packages​

This repository contains multiple packages:

  • langchain-core: Base interfaces for key abstractions as well as logic for combining them in chains (LangChain Expression Language).
  • langchain-community: Third-party integrations of various components.
  • langchain: Chains, agents, and retrieval logic that makes up the cognitive architecture of your applications.
  • langchain-experimental: Components and chains that are experimental, either in the sense that the techniques are novel and still being tested, or they require giving the LLM more access than would be possible in most production systems.
  • Partner integrations: Partner packages in libs/partners that are independently version controlled.

Each of these has its own development environment. Docs are run from the top-level makefile, but development is split across separate test & release flows.

For this quickstart, start with langchain-community:

cd libs/community

Local Development Dependencies​

Install langchain-community development requirements (for running langchain, running examples, linting, formatting, tests, and coverage):

poetry install --with lint,typing,test,test_integration

Then verify dependency installation:

make test

If during installation you receive a WheelFileValidationError for debugpy, please make sure you are running Poetry v1.6.1+. This bug was present in older versions of Poetry (e.g. 1.4.1) and has been resolved in newer releases. If you are still seeing this bug on v1.6.1+, you may also try disabling "modern installation" (poetry config installer.modern-installation false) and re-installing requirements. See this debugpy issue for more details.

Testing​

Note: In langchain, langchain-community, and langchain-experimental, some test dependencies are optional. See the following section about optional dependencies.

Unit tests cover modular logic that does not require calls to outside APIs. If you add new logic, please add a unit test.

To run unit tests:

make test

To run unit tests in Docker:

make docker_tests

There are also integration tests and code-coverage available.

Only develop langchain_core or langchain_community​

If you are only developing langchain_core or langchain_community, you can simply install the dependencies for the respective projects and run tests:

cd libs/core
poetry install --with test
make test

Or:

cd libs/community
poetry install --with test
make test

Formatting and Linting​

Run these locally before submitting a PR; the CI system will check also.

Code Formatting​

Formatting for this project is done via ruff.

To run formatting for docs, cookbook and templates:

make format

To run formatting for a library, run the same command from the relevant library directory:

cd libs/{LIBRARY}
make format

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:

make format_diff

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.

Linting​

Linting for this project is done via a combination of ruff and mypy.

To run linting for docs, cookbook and templates:

make lint

To run linting for a library, run the same command from the relevant library directory:

cd libs/{LIBRARY}
make lint

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:

make lint_diff

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.

We recognize linting 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.

Spellcheck​

Spellchecking for this project is done via codespell. Note that codespell finds common typos, so it could have false-positive (correctly spelled but rarely used) and false-negatives (not finding misspelled) words.

To check spelling for this project:

make spell_check

To fix spelling in place:

make spell_fix

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.

[tool.codespell]
...
# Add here:
ignore-words-list = 'momento,collison,ned,foor,reworkd,parth,whats,aapply,mysogyny,unsecure'

Working with Optional Dependencies​

langchain, langchain-community, and langchain-experimental rely on optional dependencies to keep these packages lightweight.

langchain-core and partner packages do not use optional dependencies in this way.

You'll notice that pyproject.toml and poetry.lock are not touched when you add optional dependencies below.

If you're adding a new dependency to Langchain, assume that it will be an optional dependency, and that most users won't have it installed.

Users who do not have the dependency installed should be able to import your code without any side effects (no warnings, no errors, no exceptions).

To introduce the dependency to a library, please do the following:

  1. Open extended_testing_deps.txt and add the dependency
  2. Add a unit test that the very least attempts to import the new code. Ideally, the unit test makes use of lightweight fixtures to test the logic of the code.
  3. Please use the @pytest.mark.requires(package_name) decorator for any unit tests that require the dependency.

Adding a Jupyter Notebook​

If you are adding a Jupyter Notebook example, you'll want to install the optional dev dependencies.

To install dev dependencies:

poetry install --with dev

Launch a notebook:

poetry run jupyter notebook

When you run poetry install, the langchain package is installed as editable in the virtualenv, so your new logic can be imported into the notebook.


Was this page helpful?


You can also leave detailed feedback on GitHub.