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.

Why contribute an integration to LangChain?

• Discoverability: LangChain is the most used framework for building LLM applications, with over 20 million monthly downloads. LangChain integrations are discoverable by a large community of GenAI builders.
• Interoptability: LangChain components expose a standard interface, allowing developers to easily swap them for each other. If you implement a LangChain integration, any developer using a different component will easily be able to swap yours in.
• Best Practices: Through their standard interface, LangChain components encourage and facilitate best practices (streaming, async, etc)

Components to Integrate

info

See the Conceptual Guide for an overview of all components supported in LangChain

While any component can be integrated into LangChain, there are specific types of integrations we encourage more:

Integrate these ✅	Not these ❌
Chat Models Tools/Toolkits Retrievers Document Loaders Vector Stores Embedding Models	LLMs (Text-Completion Models) Key-Value Stores Document Transformers Model Caches Graphs Message Histories Callbacks Chat Loaders Adapters Other abstractions

How to contribute an integration

In order to contribute an integration, you should follow these steps:

1. Confirm that your integration is in the list of components we are currently encouraging.
2. Create a package with the required dependencies (see example here).
3. Implement and test your integration following the component-specific guides.
4. Publish your integration in a Python package to PyPi.
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).

Component-specific guides

The guides below walk you through both implementing and testing specific components:

• Chat Models
• [Tools]
• [Toolkits]
• [Retrievers]
• [Document Loaders]
• [Vector Stores]
• [Embedding Models]

Standard Tests

Testing is a critical part of the development process that ensures your code works as expected and meets the desired quality standards. In the LangChain ecosystem, we have 2 main types of tests: unit tests and integration tests. These standard tests help maintain compatibility between different components and ensure reliability.

Unit Tests: Unit tests are designed to validate the smallest parts of your code—individual functions or methods—ensuring they work as expected in isolation. They do not rely on external systems or integrations.

Integration Tests: Integration tests validate that multiple components or systems work together as expected. For tools or integrations relying on external services, these tests often ensure end-to-end functionality.

Each type of integration has its own set of standard tests. Please see the relevant component-specific guide for details on testing your integration.

Co-Marketing

With over 20 million monthly downloads, LangChain has a large audience of developers building LLM applications. Besides just adding integrations, we also like to show them examples of cool tools or APIs they can use.

While traditionally called "co-marketing", we like to think of this more as "co-education". For that reason, while we are happy to highlight your integration through our social media channels, we prefer to highlight examples that also serve some educational purpose. Our main social media channels are Twitter and LinkedIn.

Here are some heuristics for types of content we are excited to promote:

• Integration announcement: If you announce the integration with a link to the LangChain documentation page, we are happy to re-tweet/re-share on Twitter/LinkedIn.
• Educational content: We highlight good educational content on the weekends - if you write a good blog or make a good YouTube video, we are happy to share there! Note that we prefer content that is NOT framed as "here's how to use integration XYZ", but rather "here's how to do ABC", as we find that is more educational and helpful for developers.
• 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 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.

// TODO: set up some form to gather these requests.