From 498f061fd7aa38b8e20115aefab8a3a46eee7fdb Mon Sep 17 00:00:00 2001 From: Jonathan Neufeld Date: Thu, 27 Nov 2025 13:38:02 -0700 Subject: [PATCH 1/3] =?UTF-8?q?(WIP)=20Adding=20LangChain=20/=20LangGraph?= =?UTF-8?q?=20=E2=87=84=20AWS=20Integration=20Details?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/oss/python/integrations/providers/aws.mdx | 28 +++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/src/oss/python/integrations/providers/aws.mdx b/src/oss/python/integrations/providers/aws.mdx index e98405e30..b832c88ef 100644 --- a/src/oss/python/integrations/providers/aws.mdx +++ b/src/oss/python/integrations/providers/aws.mdx @@ -177,6 +177,34 @@ See a [usage example](/oss/integrations/document_loaders/glue_catalog). from langchain_community.document_loaders.glue_catalog import GlueCatalogLoader ``` +## Memory +> You can use AWS databases to store LangGraph checkpointers. These could include `Amazon DynamoDB`, `Amazon Aurora`, or `ElastiCache for Valkey`. + +### Overview +> LangGraph checkpointers are used to save the state of a LangGraph thread at its current point in time. +> This allows you to pause and resume threads, or to recover from failures without losing progress. +> Refer to the [LangGraph Checkpointers documentation](/guides/langgraph/checkpointers/) for more information. + +### DynamoDB Checkpointer +> If your preferred database is DynamoDB, you can integrate the Dynamo DB Checkpointer for LangGraph. +> See a [usage example](https://github.com/langchain-ai/langchain-aws/blob/main/libs/langgraph-checkpoint-aws/README.md#4-dynamodb-checkpoint-storage). + +> For a demo, refer to this [Jupiter Notebook](https://github.com/langchain-ai/langchain-aws/blob/main/samples/memory/dynamodb_saver.ipynb) + +### Valkey Checkpointer +> If your preferred database is ElastiCache for Valkey, you can integrate the Valkey Checkpointer for LangGraph. +> See a [usage example](https://github.com/langchain-ai/langchain-aws/blob/main/libs/langgraph-checkpoint-aws/README.md#5-valkey-checkpoint-storage). + +> For a demo, refer to this [Jupiter Notebook](https://github.com/langchain-ai/langchain-aws/blob/main/samples/memory/valkey_saver.ipynb) + +### Aurora Checkpointer +> If your preferred database is Amazon Aurora, you can integrate the Aurora Checkpointer for LangGraph. +> See the [reference documentation](https://reference.langchain.com/python/langgraph/checkpoints/#langgraph.checkpoint.postgres). + +```python +from langchain_community.langgraph.checkpointers.dynamodb_checkpointer import DynamoDBCheckpointer + + ## Vector stores ### Amazon OpenSearch Service From a9c62cc84b1c476eed7da75d325a4d8823eb6fe6 Mon Sep 17 00:00:00 2001 From: Vasile Gorcinschi Date: Thu, 27 Nov 2025 17:10:57 -0500 Subject: [PATCH 2/3] docs: WIP Added pgvector and EC valkey section to AWS integrations Specifically to the Vector Stores section --- src/oss/python/integrations/providers/aws.mdx | 47 +++++++++++++++++++ 1 file changed, 47 insertions(+) diff --git a/src/oss/python/integrations/providers/aws.mdx b/src/oss/python/integrations/providers/aws.mdx index b832c88ef..dbc27b641 100644 --- a/src/oss/python/integrations/providers/aws.mdx +++ b/src/oss/python/integrations/providers/aws.mdx @@ -287,6 +287,53 @@ vds = InMemoryVectorStore.from_documents( ``` See a [usage example](/oss/integrations/vectorstores/memorydb). +### Amazon ElastiCache for Valkey + +[Amazon ElastiCache for Valkey](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/engine-versions.html) is a fully +managed, Valkey-compatible caching service that delivers ultra-fast performance. Valkey supports native vector search +capabilities to store, index and search over vector embeddings with microsecond latency an up to 99% recall. + +We need to install the `langchain-aws` and `valkey-glide` packages: + + +```bash pip + pip install langchain-aws valkey-glide +``` + +```bash uv + uv add langchain-aws valkey-glide +``` + + +See an usage example [here](https://github.com/langchain-ai/langchain-aws/blob/main/libs/langgraph-checkpoint-aws/README.md#7-valkey-store-for-document-storage). + +For a demo reference, check [this Jupyter Notebook](https://github.com/langchain-ai/langchain-aws/blob/main/samples/memory/valkey_store.ipynb) + +### Amazon Aurora PostgreSQL (pgvector) + +[Amazon Aurora PostgreSQL-Compatible Edition](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/AuroraPostgreSQL.Reference.html) with +the [pgvector](https://github.com/pgvector/pgvector) extension provides a powerful solution for storing and searching vector embeddings. `pgvector` adds +the ability to store, and search over ML-generated vector embeddings, supporting both exact and approximate near neighbor search. + +Developers can use Aurora PostgreSQL with `pgvector` as a unified store for both RAG retrieval and agentic long-term memory, +simplifying architecture by consolidating semantic search capabilities in a single managed database. + +To leverage this integration, we need to install the `langchain-postgres` package: + + +```bash pip + pip install langchain-postgres +``` + +```bash uv + uv add langchain-postgres +``` + + +Refer to [pgvector integration documentation](https://docs.langchain.com/oss/python/integrations/vectorstores/pgvector) for detailed usage instructions. + +For a comprehensive guide on using `pgvector` with Aurora PostgreSQL for RAG applications, consider reading [this AWS Blog post](https://aws.amazon.com/blogs/database/leverage-pgvector-and-amazon-aurora-postgresql-for-natural-language-processing-chatbots-and-sentiment-analysis/). + ## Retrievers ### Amazon Kendra From 3949f0ff047d14ec74965daa29168ac236621b05 Mon Sep 17 00:00:00 2001 From: Jonathan Neufeld Date: Thu, 27 Nov 2025 21:42:48 -0700 Subject: [PATCH 3/3] Elaborate on LangGraph checkpointers documentation --- src/oss/python/integrations/providers/aws.mdx | 49 +++++++++++++++---- 1 file changed, 39 insertions(+), 10 deletions(-) diff --git a/src/oss/python/integrations/providers/aws.mdx b/src/oss/python/integrations/providers/aws.mdx index dbc27b641..6c88fd51d 100644 --- a/src/oss/python/integrations/providers/aws.mdx +++ b/src/oss/python/integrations/providers/aws.mdx @@ -178,7 +178,18 @@ from langchain_community.document_loaders.glue_catalog import GlueCatalogLoader ``` ## Memory -> You can use AWS databases to store LangGraph checkpointers. These could include `Amazon DynamoDB`, `Amazon Aurora`, or `ElastiCache for Valkey`. +> You can use AWS databases to store `LangGraph` checkpointers. These could include `Amazon DynamoDB`, `Amazon Aurora`, or `ElastiCache for Valkey`. +> To use these, install the `langgraph-checkpoint-aws` library: + + + ```bash pip + pip install langgraph-checkpoint-aws + ``` + + ```bash uv + uv add langgraph-checkpoint-aws + ``` + ### Overview > LangGraph checkpointers are used to save the state of a LangGraph thread at its current point in time. @@ -186,24 +197,42 @@ from langchain_community.document_loaders.glue_catalog import GlueCatalogLoader > Refer to the [LangGraph Checkpointers documentation](/guides/langgraph/checkpointers/) for more information. ### DynamoDB Checkpointer -> If your preferred database is DynamoDB, you can integrate the Dynamo DB Checkpointer for LangGraph. -> See a [usage example](https://github.com/langchain-ai/langchain-aws/blob/main/libs/langgraph-checkpoint-aws/README.md#4-dynamodb-checkpoint-storage). +> If your preferred database is DynamoDB, you can integrate the Dynamo DB Checkpointer for LangGraph. -> For a demo, refer to this [Jupiter Notebook](https://github.com/langchain-ai/langchain-aws/blob/main/samples/memory/dynamodb_saver.ipynb) +> See a [usage example](https://github.com/langchain-ai/langchain-aws/blob/main/libs/langgraph-checkpoint-aws/README.md#4-dynamodb-checkpoint-storage), +> and for a demo, refer to this [Jupiter Notebook](https://github.com/langchain-ai/langchain-aws/blob/main/samples/memory/dynamodb_saver.ipynb). ### Valkey Checkpointer > If your preferred database is ElastiCache for Valkey, you can integrate the Valkey Checkpointer for LangGraph. -> See a [usage example](https://github.com/langchain-ai/langchain-aws/blob/main/libs/langgraph-checkpoint-aws/README.md#5-valkey-checkpoint-storage). -> For a demo, refer to this [Jupiter Notebook](https://github.com/langchain-ai/langchain-aws/blob/main/samples/memory/valkey_saver.ipynb) +> See a [usage example](https://github.com/langchain-ai/langchain-aws/blob/main/libs/langgraph-checkpoint-aws/README.md#5-valkey-checkpoint-storage), +> and for a demo, refer to this [Jupiter Notebook](https://github.com/langchain-ai/langchain-aws/blob/main/samples/memory/valkey_saver.ipynb) ### Aurora Checkpointer -> If your preferred database is Amazon Aurora, you can integrate the Aurora Checkpointer for LangGraph. -> See the [reference documentation](https://reference.langchain.com/python/langgraph/checkpoints/#langgraph.checkpoint.postgres). +> If your preferred database is `Amazon Aurora`, you can integrate the `Postgres` Checkpointer for LangGraph. +> To use this checkpointer you'll need to install the `langgraph-checkpoint-postgres` library: -```python -from langchain_community.langgraph.checkpointers.dynamodb_checkpointer import DynamoDBCheckpointer + + ```bash pip + pip install langgraph-checkpoint-postgres + ``` + + ```bash uv + uv add langgraph-checkpoint-postgres + ``` + + +> A simple example of using the `PostgresSaver` checkpointer instance is shown below (without connection pooling): + + ```python + from langgraph.checkpoint.postgres import PostgresSaver + + with PostgresSaver.from_conn_string(os.getenv("DB_URI")) as checkpointer: + # use the checkpointer + ``` + +> See the [reference documentation](https://reference.langchain.com/python/langgraph/checkpoints/#langgraph.checkpoint.postgres) for details. ## Vector stores