langchain/docs/docs/contributing/integrations.mdx

---
sidebar_position: 5
---

# Contribute Integrations

To begin, make sure you have all the dependencies outlined in guide on [Contributing Code](/docs/contributing/code/).

There are a few different places you can contribute integrations for LangChain:

- **Community**: For lighter-weight integrations that are primarily maintained by LangChain and the Open Source Community.
- **Partner Packages**: For independent packages that are co-maintained by LangChain and a partner.

For the most part, new integrations should be added to the Community package. Partner packages require more maintenance as separate packages, so please confirm with the LangChain team before creating a new partner package.

In the following sections, we'll walk through how to contribute to each of these packages from a fake company, `Parrot Link AI`.

## Community package

The `langchain-community` package is in `libs/community` and contains most integrations.

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
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 
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:

```python
from langchain_core.language_models.chat_models import BaseChatModel

class ChatParrotLink(BaseChatModel):
    """ChatParrotLink chat model.

    Example:
        .. code-block:: python

            from langchain_community.chat_models import ChatParrotLink

            model = ChatParrotLink()
    """

    ...
```

And we would write tests in:

- Unit tests: `libs/community/tests/unit_tests/chat_models/test_parrot_link.py`
- Integration tests: `libs/community/tests/integration_tests/chat_models/test_parrot_link.py`

And add documentation to:

- `docs/docs/integrations/chat/parrot_link.ipynb`

## Partner package in LangChain repo

Partner packages can be hosted in the `LangChain` monorepo or in an external repo.

Partner package in the `LangChain` repo is placed in `libs/partners/{partner}` 
and the package source code is in `libs/partners/{partner}/langchain_{partner}`.

A package is 
installed by users with `pip install langchain-{partner}`, and the package members 
can be imported with code like:

```python
from langchain_{partner} import X
```

### Set up a new package

To set up a new partner package, use the latest version of the LangChain CLI. You can install or update it with:

```bash
pip install -U langchain-cli
```

Let's say you want to create a new partner package working for a company called Parrot Link AI.

Then, run the following command to create a new partner package:

```bash
cd libs/partners
langchain-cli integration new
> Name: parrot-link
> Name of integration in PascalCase [ParrotLink]: ParrotLink
```

This will create a new package in `libs/partners/parrot-link` with the following structure:

```
libs/partners/parrot-link/
  langchain_parrot_link/ # folder containing your package
    ...
  tests/
    ...
  docs/ # bootstrapped docs notebooks, must be moved to /docs in monorepo root
    ...
  scripts/ # scripts for CI
    ...
  LICENSE
  README.md # fill out with information about your package
  Makefile # default commands for CI
  pyproject.toml # package metadata, mostly managed by Poetry
  poetry.lock # package lockfile, managed by Poetry
  .gitignore
```

### Implement your package

First, add any dependencies your package needs, such as your company's SDK:

```bash
poetry add parrot-link-sdk
```

If you need separate dependencies for type checking, you can add them to the `typing` group with:

```bash
poetry add --group typing types-parrot-link-sdk
```

Then, implement your package in `libs/partners/parrot-link/langchain_parrot_link`.

By default, this will include stubs for a Chat Model, an LLM, and/or a Vector Store. You should delete any of the files you won't use and remove them from `__init__.py`.

### Write Unit and Integration Tests

Some basic tests are presented in the `tests/` directory. You should add more tests to cover your package's functionality.

For information on running and implementing tests, see the [Testing guide](/docs/contributing/testing/).

### Write documentation

Documentation is generated from Jupyter notebooks in the `docs/` directory. You should place the notebooks with examples
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. 
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 
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
`libs/community/langchain_community/chat_models/parrot_link.py`.

Before our change, our chat model might look like this:

```python
class ChatParrotLink(BaseChatModel):
  ...
```

After our change, it would look like this:

```python
from langchain_core._api.deprecation import deprecated

@deprecated(
    since="0.0.<next community version>", 
    removal="0.2.0", 
    alternative_import="langchain_parrot_link.ChatParrotLink"
)
class ChatParrotLink(BaseChatModel):
  ...
```

You should do this for *each* component that you're migrating to the partner package.

### Additional steps

Contributor steps:

- [ ] Add secret names to manual integrations workflow in `.github/workflows/_integration_test.yml`
- [ ] Add secrets to release workflow (for pre-release testing) in `.github/workflows/_release.yml`

Maintainer steps (Contributors should **not** do these):

- [ ] set up pypi and test pypi projects
- [ ] add credential secrets to Github Actions
- [ ] add package to conda-forge

## Partner package in external repo

Partner packages in external repos must be coordinated between the LangChain team and
the partner organization to ensure that they are maintained and updated.

If you're interested in creating a partner package in an external repo, please start
with one in the LangChain repo, and then reach out to the LangChain team to discuss
how to move it to an external repo.