# langchain-aws: LangChain and LangGraph components for Bedrock, SageMaker and AgentCore

> The langchain-aws monorepo replaces the AWS integrations that used to live in langchain-community. It ships three PyPI packages covering chat models, vector stores, retrievers, graph components, LangGraph checkpointers and AgentCore sandboxes, all under MIT.

**langchain-ai/langchain-aws** — Build LangChain Applications on AWS

- Repository: https://github.com/langchain-ai/langchain-aws
- Stars: 350 · Forks: 310
- Language: Python
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/langchain-ai-langchain-aws

## The problem langchain-aws solves: AWS integrations that used to ship inside langchain-community

AWS support in LangChain used to arrive through langchain-community, a package that aggregates integrations for hundreds of unrelated services. The README states plainly that this monorepo "aims to replace and expand upon the existing LangChain AWS components found in the langchain-community package", and adds a migration note telling users they are "encouraged to migrate to this repository as soon as possible". If you maintain a RAG pipeline or an agent that talks to Bedrock, that sentence is the whole reason this repository exists: your integration code now has a home with AWS-specific release notes instead of a shared changelog.

The audience is narrow but real. You are a Python developer already committed to LangChain or LangGraph abstractions, and your models, retrievers or checkpoints live on AWS. The repository covers chat models for Bedrock and SageMaker endpoints, vector stores for Amazon MemoryDB, S3 Vectors and ElastiCache for Valkey, retrievers for Amazon Kendra and Knowledge Bases for Amazon Bedrock, graph components for AWS Neptune, Runnables for Bedrock Agents, and tools for Bedrock AgentCore. If none of those names appear in your architecture, the package adds a dependency layer you do not need.

## How the monorepo is laid out and how the three packages divide the work

The repository is a monorepo with a libs/ directory at the top level, alongside samples/, .github/, AGENTS.md, CLAUDE.md and llms.txt. Three distributions are published from it. langchain-aws carries the LangChain-facing classes: LLMs, vector stores, retrievers, graph components, agents and tools. langgraph-checkpoint-aws carries the LangGraph persistence layer, with checkpointers for Bedrock AgentCore Memory, Bedrock Session Management, DynamoDB and ElastiCache Valkey, plus memory stores for AgentCore Memory and ElastiCache Valkey. langchain-agentcore-codeinterpreter carries a sandbox backend that lets Deep Agents execute code inside AgentCore Code Interpreter MicroVMs.

That split matters more than the directory listing suggests. The checkpointing code changes on its own schedule, and the release history shows it: langgraph-checkpoint-aws==1.2.3 was published on 2026-09-03, while langchain-aws==1.7.5 landed on 2026-09-02 and langchain-aws==1.7.4 on 2026-08-26. The two packages version independently, so a LangGraph user who only needs DynamoDB persistence does not inherit the Bedrock model classes. The cost is that you now track two version numbers instead of one, and the README does not publish a compatibility matrix tying a given langchain-aws release to a given langgraph-checkpoint-aws release.

## Installing langchain-aws and calling ChatBedrockConverse for the first time

All three packages install from PyPI under their own names. The README gives the install command for each; there is no meta-package and no extras syntax documented.

```bash
pip install langchain-aws
```

After that, the README's usage example constructs a Bedrock chat model and invokes it with a plain string. Note the model id in the example, which uses a cross-region inference prefix rather than a bare model name.

```python
from langchain_aws import ChatBedrockConverse

# Initialize the Bedrock chat model
model = ChatBedrockConverse(
    model="us.anthropic.claude-sonnet-4-5-20250929-v1:0"
)

# Invoke the model
response = model.invoke("Hello! How are you today?")
print(response)
```

What you should see is the response object printed to stdout, not a string. ChatBedrockConverse returns an AIMessage, so the printed value carries the message content plus metadata. The example does not pass credentials or a region, which means it relies on whatever AWS credential chain and region your environment already provides; the README does not document how those are resolved.

If your agent needs browser automation or code execution rather than a chat model, the AgentCore tools install separately and are created through factory functions that take a region.

```python
from langchain_aws.tools import create_browser_toolkit, create_code_interpreter_toolkit

browser_toolkit, browser_tools = create_browser_toolkit(region="us-west-2")
code_toolkit, code_tools = await create_code_interpreter_toolkit(region="us-west-2")
```

The README pairs those toolkits with create_react_agent and an ainvoke call keyed on a thread_id, then calls cleanup() on both toolkits. The cleanup step is part of the documented flow, not an optional flourish: the example ends with `await browser_toolkit.cleanup()` and `await code_toolkit.cleanup()`. For LangGraph persistence, install the second package instead.

```bash
pip install langgraph-checkpoint-aws
```

The top-level README does not show checkpoint usage inline. It links to libs/langgraph-checkpoint-aws/README.md for the examples, so that file is where you go next.

## Where langchain-aws is the wrong tool

The clearest failure mode is scope mismatch. If your application calls one Bedrock model and nothing else, boto3 already does that with fewer layers, and the README's own migration note only argues for moving off langchain-community, not for adopting LangChain in the first place. Nothing in the repository claims to replace the AWS SDK.

The second limitation is documentation depth in the top-level README. It is a feature inventory with three short usage blocks. The checkpointers, memory stores, Neptune graph components, Kendra retrievers and SageMaker LLM classes are named but not demonstrated there; the README defers to the LangChain docs site and to the per-package README. If you need to know which DynamoDB table attributes a checkpointer expects, or how ElastiCache Valkey memory stores handle expiry, the top-level README will not tell you.

Third, the AgentCore example is async and stateful. The code interpreter toolkit is created with await, the agent is invoked with ainvoke, and both toolkits must be cleaned up. Dropping the cleanup calls is not addressed anywhere in the README, so the behaviour of a leaked toolkit is undocumented rather than described as safe. Treat the sample as a lifecycle you have to manage, not a fire-and-forget helper.

Finally, the repository is explicit that it is still growing: the feature list ends with "...and more to come", and the migration note says users should move "as soon as possible". That is a direction of travel, not a completion statement.

## How langchain-aws differs from langchain-community and from calling boto3 directly

The honest alternative is langchain-community, the package this repository is designed to supersede. The difference is not capability today; it is ownership and surface area. langchain-community bundles AWS integrations next to integrations for hundreds of other providers, so an AWS-specific change rides a release train driven by unrelated services. langchain-aws splits that surface into three packages with their own release notes and their own version numbers, which is why langgraph-checkpoint-aws can sit at 1.2.3 while langchain-aws sits at 1.7.5. If you are starting fresh, the README's migration note points one way. If you have a working langchain-community deployment, the difference is the cost of moving your imports and re-testing your Bedrock and retriever paths.

The second alternative is boto3 with no LangChain at all. That approach gives you direct control over request shapes, retries and credentials, and it has no opinion about how you compose prompts or persist agent state. What it does not give you is the abstraction layer: Runnable interfaces, a uniform message type across models, and LangGraph checkpointers that write agent state into DynamoDB or Valkey. The trade is real in both directions. langchain-aws is the right side of that trade only when you are already building on LangChain or LangGraph primitives and want the AWS bindings to come from a package that AWS integration work is actively landing in.

## Maintenance, version tracking and what the MIT licence means here

The repository is not archived, and the last push was on 2026-09-10. Releases are recent and frequent: langchain-aws==1.7.5 on 2026-09-02, langgraph-checkpoint-aws==1.2.3 on 2026-09-03, and langchain-aws==1.7.4 on 2026-08-26. That cadence is the upgrade cost you are signing up for. Patch releases inside a minor line are cheap, but the two packages move independently, and the README does not state which langchain-aws version pairs with which langgraph-checkpoint-aws version. Pin both in your lockfile and read the release notes for each before bumping.

The licence is MIT, declared in the LICENSE file at the repository root and repeated in the README's License section. MIT is permissive: it allows commercial use, modification and redistribution with the licence text retained. That is a statement about the repository's own code. It says nothing about the AWS services the packages call, which carry their own pricing and terms, and nothing about the model providers behind Bedrock. If your legal position depends on those service terms, the repository's licence file is not where that question is answered.

## Conclusion

Adopt langchain-aws if you are already building on LangChain or LangGraph and want your Bedrock, SageMaker, Kendra, MemoryDB or AgentCore wiring to come from a package that is explicitly positioned as the successor to the AWS integrations in langchain-community. Do not adopt it if you only need raw boto3 calls against one Bedrock model, or if you are not willing to track three separate package versions and their release cadence. Before committing, verify which of the three packages you actually need, check that your Bedrock model id is available in your region, and read the langgraph-checkpoint-aws README for the checkpointing service you intend to use, because the top-level README only links to it.

## FAQ

### How do I install langchain-aws?

Install it from PyPI with pip install langchain-aws. The LangGraph checkpointing code lives in a separate distribution, langgraph-checkpoint-aws, which installs with its own pip command. The AgentCore sandbox backend is a third package, langchain-agentcore-codeinterpreter.

### What is langchain-aws?

It is a monorepo of LangChain and LangGraph components for AWS services, published as the langchain-aws, langgraph-checkpoint-aws and langchain-agentcore-codeinterpreter packages. The README describes it as replacing and expanding on the AWS components previously found in langchain-community.

### Is there an alternative to langchain-aws?

The README positions langchain-aws as the successor to the AWS integrations in langchain-community, so that package is the migration source rather than an alternative to move toward. Calling boto3 directly remains an option if you do not need LangChain or LangGraph abstractions.

## Sources

- [Issues](https://github.com/langchain-ai/langchain-aws/issues)
- [langchain-ai/langchain-aws on GitHub](https://github.com/langchain-ai/langchain-aws)
- [License: MIT](https://github.com/langchain-ai/langchain-aws/blob/main/LICENSE)
- [README](https://github.com/langchain-ai/langchain-aws/blob/main/README.md)
- [Releases](https://github.com/langchain-ai/langchain-aws/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/langchain-ai-langchain-aws