From 5fa196ab38d2a7530149ef4331d0f178c3d074cc Mon Sep 17 00:00:00 2001 From: William FH <13333726+hinthornw@users.noreply.github.com> Date: Tue, 3 Dec 2024 19:51:25 -0800 Subject: [PATCH] Update docstrings for store classes (#2616) --- ...3-a466-46ad-aafe-2b870831057e.msgpack.zlib | 2 +- ...b-d730-48bd-9652-983812fd7811.msgpack.zlib | 2 +- ...0-1f8a-4057-81c4-b7bf073dc4c1.msgpack.zlib | 2 +- docs/docs/cloud/deployment/semantic_search.md | 123 ++++++++++++ docs/docs/concepts/memory.md | 30 ++- .../how-tos/cross-thread-persistence.ipynb | 15 +- docs/docs/how-tos/index.md | 2 + .../langgraph/store/postgres/aio.py | 62 ++++++ .../langgraph/store/postgres/base.py | 46 +++++ .../langgraph/store/base/__init__.py | 184 +++++++++++++++--- .../langgraph/store/memory/__init__.py | 118 ++++++++--- libs/sdk-js/src/client.ts | 3 + libs/sdk-js/src/schema.ts | 12 +- 13 files changed, 533 insertions(+), 68 deletions(-) create mode 100644 docs/docs/cloud/deployment/semantic_search.md diff --git a/docs/cassettes/cross-thread-persistence_c871a073-a466-46ad-aafe-2b870831057e.msgpack.zlib b/docs/cassettes/cross-thread-persistence_c871a073-a466-46ad-aafe-2b870831057e.msgpack.zlib index 923a74528..1253235cc 100644 --- a/docs/cassettes/cross-thread-persistence_c871a073-a466-46ad-aafe-2b870831057e.msgpack.zlib +++ b/docs/cassettes/cross-thread-persistence_c871a073-a466-46ad-aafe-2b870831057e.msgpack.zlib @@ -1 +1 @@ -eNqFVG1sU1UYLkIIGkA0GkkY7Fid8Qenve1tR9uQYO0Ax6gbW0GKEXJ27rnttfeLe07HPiTKwKAjkVxJGCrG6LqWlA26AGrAKYmQGPWHhhgsBELUGP/4C6KJBua5XcsgW2Z/NPee9+t5n+c5t7/QRSyqGPqcEUVnxEKY8Rdq9xcssjNLKNuX1whLG1KurbUjMZS1lHJDmjGTRrxeZCoepLO0ZZgK9mBD83b5vBqhFKUIzXUaUk/5hz63hrp3MCNDdOqOAJ/gD6wE7loSP3m5z20ZKuFP7iwllptHscGR6Mw5ekF5ErQTjWidxIoArQfoSCNAoeB5o9O9+xWnlSER1UnFKspKBIowCKmh64RBPx8mNPoFpyftoYxoTl7SyAJkEYBAmqimnFUBolShjG8CGFIzip4CzAAsTYADyAM283+g6LLBi3cX0gRJnLGDubRBmT02jYOTCGNiMkh0bEi8lz2a6lXMlUAisooYKWIHW4Vku5ghxIRIVbpIfrLKLiHTVBWMnLj3Vb7HSJUMyHpMMj1cdCBCTqXO7M+iNRzeth4umQ4Ejxjw+EvdkG+n6ConHaqIQ8qblfi5ewMmwhneB1btYOcni0/cm2NQeziOcGvHfS2RhdP2MLK0xsCpe8+trM4UjdiFWNv0cdXg1DjR4/N5wmP3NaY9OraHZaRSMnaX5LslRa6vCIVGKPhO1FhSiZ5iaXvIL4SOWYSa3Mpkb563ZFnan+OKkO+/KVTd90lrS03N665Hc01cHXt8naWsBEIAtGIGHP8AXyjiD0cEP1gfT4zEqmMSM4oxlrCQTmUuyNqa+AWczuoZIhVjM8pedk+tZfH5qqIpDFZvHhfLebVzAUEQys/MmmkRjbPmTMyJ4XD4f/pyZgizTzv7QZ8AhUBicstgYFsZzFQ5eX+rePIOHo7o6Vkyp/DUssGs2TPjEfzbilXQUJHsL/jzDsHXviqeifokRuM0bMbFYCiTNMPBM90Qq0ZWgox/wwisGKKb2WXQKRA50BiSRTEoiqIkBcOyLAeCZJUoyVK4kQx1Kcgu+jw+kDKMlEpOxtbBGMJpAjsqtrELTckXo/Hm2MhW2G50Gpy/BOI864ZO8h3E4na0i5XR/IJbJM/L26NJ+3QIS6tE7MeBkBwMiGEM177UXqoZ6K5Bcs7XofKt3MNtavGji3OW1B9Y4Kr85iYORlu+fm7JmxPfhga3N767Dp59IvrYlQMLBgbc6NDCIBM7dsmjw7e+aimuWL3otZvXfx1f/tfy3jqWHLx0NXmz+9LqNQmvcqb52q2bvXSC7V+snctvWltEzX8IzXXRtj9/emBZpC439NaKq0ut9Rebd245Jhx6fHPyw8Onik37R0uPLPvn8rUdx368nF5Td5AObLqx4f2ntv7ctOffw+fnzXfvHf0Nb93Yua9p7qJFDaW/zRsPhhbOG3/nOj7y3fwr50tvfDQwNG/j2dL4hdsfxILJy2/3PzS0/pcTnx5d+nr9hvr3Pm+4dRSzIw8fv724b3vqeHzLhYEvI7ueLd/5+MDtO8tcromJua7fPfHBjjku1385MZ/f \ No newline at end of file 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 \ No newline at end of file diff --git a/docs/cassettes/cross-thread-persistence_d362350b-d730-48bd-9652-983812fd7811.msgpack.zlib b/docs/cassettes/cross-thread-persistence_d362350b-d730-48bd-9652-983812fd7811.msgpack.zlib index 795ff5279..3675bd448 100644 --- a/docs/cassettes/cross-thread-persistence_d362350b-d730-48bd-9652-983812fd7811.msgpack.zlib +++ b/docs/cassettes/cross-thread-persistence_d362350b-d730-48bd-9652-983812fd7811.msgpack.zlib @@ -1 +1 @@ -eNqFVHlsFFUcXiyIgTYg3gFkWO7j7c7sbrtsRcyy3KVsabdCMUJe37zdme7szHTe2x5UgpRLhEgmHiTGEAPbXdm00NoiIaAGFAE1QkgIbEgANQT/kIQQDFY5fLPd5QgNzh+Tmd/5/b7f915rqgEbRNbUAe2ySrEBEWU/xGxNGbg+jgndkIxhKmlioiJYFdodN+TMBIlSnZQ6nVCXHVClkqHpMnIgLeZsEJwxTAiMYJKo1cTmzPct9hhsWkW1KFaJvZQTeJdnOmfPBzHLWy12Q1Mw+7LHCTbszIs0hkSllqlRgpSTCRdr5lQYw2/Y17xtpWsiViw3UmBcxMANigHRVBVT4GIN+BIXb9UhzYTimBVXo8U5aGAOchJW9HBc4SAhMqEMPUehEpXVCEc1jkqYs0A4uGr25mQ1rLHkNSkJQ5GxtD0haYSaXY/NvQ8ihHUKsIo0kdUyOyKrZX06J+KwAilOIwtbllgzHcVYB1CRG3CyL8vshLquyAhafmcdm6M9RwCgzTp+3J22IAJGn0rNA/48DmdFM1uTyvEOt8fh6mwCbDpZVRjRQIEMUlLP+g897NAhirI6ICcBM9mXvPfhGI2YbeUQBaseKQkNJJlt0IiVeLofthtxlcoxbKYCFY+3yzkftHM7BMHh63qkMGlWkdkWhgrBXfdJvp+SZvt1A74E8MLePEsKViNUMncLvpIvDEx0Jl+8PslK0jhpTbCN4J9PpHKK2xUsy2/zom1EYg7bjvn1PEOezvEeLogoZ+mHE2aUunylzDK/PNQeyLUJ9buMrpABVRJmC5mbX34KSXE1isV0oN+1Z+wPxjJYf0WOyRTkThtblvVrJjw8z2cmPjHSwDHGmtUx4fb5fP9TlzGDqdljzQcEHvCeUN+UxZ4VGa6/zL4zm8OTtPAwROOfEPkATz6ae2J0/3h4z4p0DjSQRfMw+17FCxXRCEKLPdF6b039kmhZXXFj06Jo/f4mgBQtLgLK7i0MsoJoomaG87p8XkEQisPe8AyvKIphEYsC9kIXqnXBWgR3N8jQTAsOgYtoWkTB+wLzQAAiCYOqrGzM1JyaJf7yhYH25aBSq9UYfyHIeFY1FSersMHkaKazrdkBN3CSpVf6a8yeGUj0upHb40VY9Lh9CMxdVtmZF9B9gSSs2yF7P65jMjWY6diAyJitz9iyT4Fi+qMj/YUb771/+tiOev2r+OQWtw8c3DBqSGxKeOa4C4Fw28kFvzeg25d++jQJJkzakkoFh9Efnu86vnTYhbPXrg5effuj386du44O9M6+9c1rsz4uKu3Zc/pPe/Vaji6fcKp1WXndzqLRH4yYgraP/fdFuRceXJnmPwSHqm/Vx891nIbDS2q/u3uht6juJln57SevDr4+98tRZ6b5zhevH7Dr+tHLfwQH7py04PCO0tVlRy83nimcKL9wfjstGDnoVOcrl4OuW2PGDqwc9NzkUPX5q43vlu+Z6vmluzgz2z90Y0/wyNWZ/j3GItM+flMvHT5r6dlpvz696c4o6dmxqYhBhh1xv3ylcNydoqE7xxVu/QzO12+2LSbp5MCTF08IspR2v+S8NDq9MPPmjanbXh9xvGP/j3+3fH7zzHsF8BSIbL72T/vdbVvKujtOurtqL3WMXtS9tu3QX1duDLXZ7t0rsCWnrXtnyFM223+sv8iH \ No newline at end of file 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 \ No newline at end of file diff --git a/docs/cassettes/cross-thread-persistence_d862be40-1f8a-4057-81c4-b7bf073dc4c1.msgpack.zlib b/docs/cassettes/cross-thread-persistence_d862be40-1f8a-4057-81c4-b7bf073dc4c1.msgpack.zlib index 7a4f441ea..290b07eca 100644 --- a/docs/cassettes/cross-thread-persistence_d862be40-1f8a-4057-81c4-b7bf073dc4c1.msgpack.zlib +++ b/docs/cassettes/cross-thread-persistence_d862be40-1f8a-4057-81c4-b7bf073dc4c1.msgpack.zlib @@ -1 +1 @@ -eNqFVG1oHEUYvlDQ+sMPqggGwfFoU5HM3e7d5i4XBY2XxLQ1HyZX8iGlndudvd3e7uy6O5fetUZqEm1sSdulCIKlBXO5K9eYJm3qB7Ui2B+KFhTqj6MqVBAs8YcW/KxtnL3cJSkJcVmW2Xm/nvd5n5mh/AC2bNUgVZMqodhCImU/tjOUt/DLKWzTkZyOqWJI2c6O7th4ylKLmxRKTbvB70em6kOEKpZhqqJPNHT/AO/XsW2jBLazcUPKFK/s8+oovZMaSUxsbwPguYBQC7wVJ7bz0j6vZWiYrbwpG1teZhUNhoRQd2uPgihQbaBnAEE6fsY7uMMNNySsuWZRQykJwyCsg7ZBCKYwwApwoQDn5rEzNsW669dnpACyMEBAwZoppzSAbFu1KUMPKNKSKkkAagCqYOCC8IHt7AtUIhsNC0u3uIvjOSPuHcwrGEmMtSNZxbCpM7OChzNIFLFJISaiIbHcznuJvapZCyQsa4jiguhiLRHtFJIYmxBp6gDOLUQ508g0NVVErt2/m/U1WSYE0oyJV5oLLmTI6CTU+aCxgsPfmWFjI4DzBQVfYDoNWbcq0RjxUEMMUs4s2S8sN5hITLI8sCwJJ7cQPLXcx7CdiTYkdnTfkRJZouJMIEsPCeeW71spQlUdO/lo58pyZeNSuaCP532RmTsS2xkiOhMy0mw8s0jyYkiBzTsIuRDk+KkKSxomCao44wE+cMrCtsnkjIdzLCVN2UNZNhH81ef5sgLf7dhWmeYPng3ZJjYd52KLpdYCTgAdIgWungBf3xCINHAB8HxbbDJaLhNbdRgzMQsRW2YDaa4MPy8qKZLEUiG66tiL3qW2LFZfU3WVwvLpY8Nyf52swHFcsWZNTwvrjDW3YjYYiUT+Jy9jBlNn1u0P8hzkhNhCl3VCfxGsFrlwhst4ci4ehmjjGp5LeCreYE3v1fFwgf5CGTRUJedjtt7J8W1Iifa0b+sVd0vp7e2tAdqeDCvy+TQUNSMlQcruMQxLgkhTpwjiclyuY28wGBLCKBQOcjyW5XBIkgUUiGBhfEBFToH38SBhGAkNn4m2wCgSFQy7S7Jx8k197Y1tW6KTvbDLiBuMvxhiPBOD4Fw3tpgcnUKpNDvgFs6x8K7GPme2XpTCQTHIx+vrOSEYEWFzT9d0RUCLAsm6t0PpvnyNydRiW5euPnZovaf0rHvh8FPJz559YGT+4Nv/PCQVM39t7al5/7TAPz56iOgjEzuaLyQ2jNzed3QL+PbT8P1y04PXvrn+0ZMPX50jF38+4c/fuvGr9f0vP8798Vt6//Dgn0K+te74PfcNzwbXF8b6dw1HNzv96St6q3MDv3ryNHfsJ/zi1MEDZ/dHoXbprvnQ7bHqwcu/v5N+dNO9jxw4fLbl3Ngr36G9ezqPfVL9xCnu6VERq7v+rd568s0Pa9Lt+txRsvnW6Bs3pbe+eL332pfnhzfePHIid/1uj2d+fp3n76+rL1dVeTz/AbjckGA= \ No newline at end of file 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 \ No newline at end of file diff --git a/docs/docs/cloud/deployment/semantic_search.md b/docs/docs/cloud/deployment/semantic_search.md new file mode 100644 index 000000000..918d0e3df --- /dev/null +++ b/docs/docs/cloud/deployment/semantic_search.md @@ -0,0 +1,123 @@ +# How to add semantic search to your LangGraph deployment + +This guide explains how to add semantic search to your LangGraph deployment's cross-thread [store](../../concepts/persistence.md#memory-store), so that your agent can search for memories and other documents by semantic similarity. + +## Prerequisites + +- A LangGraph deployment (see [how to deploy](setup_pyproject.md)) +- API keys for your embedding provider (in this case, OpenAI) +- `langchain >= 0.3.8` (if you specify using the string format below) + +## Steps + +1. Update your `langgraph.json` configuration file to include the store configuration: + +```json +{ + ... + "store": { + "index": { + "embed": "openai:text-embeddings-3-small", + "dims": 1536, + "fields": ["$"] + } + } +} +``` + +This configuration: + +- Uses OpenAI's text-embeddings-3-small model for generating embeddings +- Sets the embedding dimension to 1536 (matching the model's output) +- Indexes all fields in your stored data (`["$"]` means index everything, or specify specific fields like `["text", "metadata.title"]`) + +2. To use the string embedding format above, make sure your dependencies include `langchain >= 0.3.8`: + +```toml +# In pyproject.toml +[project] +dependencies = [ + "langchain>=0.3.8" +] +``` + +Or if using requirements.txt: + +``` +langchain>=0.3.8 +``` + +## Usage + +Once configured, you can use semantic search in your LangGraph nodes. The store requires a namespace tuple to organize memories: + +```python +def search_memory(state: State, *, store: BaseStore): + # Search the store using semantic similarity + # The namespace tuple helps organize different types of memories + # e.g., ("user_facts", "preferences") or ("conversation", "summaries") + results = store.search( + namespace=("memory", "facts"), # Organize memories by type + query="your search query", + k=3 # number of results to return + ) + return results +``` + +## Custom Embeddings + +If you want to use custom embeddings, you can pass a path to a custom embedding function: + +```json +{ + ... + "store": { + "index": { + "embed": "path/to/embedding_function.py:embed", + "dims": 1536, + "fields": ["$"] + } + } +} +``` + +The deployment will look for the function in the specified path. The function must be async and accept a list of strings: + +```python +# path/to/embedding_function.py +from openai import AsyncOpenAI + +client = AsyncOpenAI() + +async def aembed_texts(texts: list[str]) -> list[list[float]]: + """Custom embedding function that must: + 1. Be async + 2. Accept a list of strings + 3. Return a list of float arrays (embeddings) + """ + response = await client.embeddings.create( + model="text-embedding-3-small", + input=texts + ) + return [e.embedding for e in response.data] +``` + +## Querying via the API + +You can also query the store using the LangGraph SDK. Since the SDK uses async operations: + +```python +from langgraph_sdk import get_client + +async def search_store(): + client = get_client() + results = await client.store.search( + namespace=("memory", "facts"), + query="your search query", + limit=3 # number of results to return + ) + return results + +# Use in an async context +results = await search_store() +``` diff --git a/docs/docs/concepts/memory.md b/docs/docs/concepts/memory.md index 49eb8e118..126b35993 100644 --- a/docs/docs/concepts/memory.md +++ b/docs/docs/concepts/memory.md @@ -171,7 +171,7 @@ trim_messages( ## Long-term memory -Long-term memory in LangGraph allows systems to retain information across different conversations or sessions. Unlike short-term memory, which is thread-scoped, long-term memory is saved within custom "namespaces." +Long-term memory in LangGraph allows systems to retain information across different conversations or sessions. Unlike short-term memory, which is **thread-scoped**, long-term memory is saved within custom "namespaces." ### Storing memories @@ -180,16 +180,34 @@ LangGraph stores long-term memories as JSON documents in a [store](persistence.m ```python from langgraph.store.memory import InMemoryStore + +def embed(texts: list[str]) -> list[list[float]]: + # Replace with an actual embedding function or LangChain embeddings object + return [[1.0, 2.0] * len(texts)] + + # InMemoryStore saves data to an in-memory dictionary. Use a DB-backed store in production use. -store = InMemoryStore() +store = InMemoryStore(index={"embed": embed, "dims": 2}) user_id = "my-user" application_context = "chitchat" namespace = (user_id, application_context) -store.put(namespace, "a-memory", {"rules": ["User likes short, direct language", "User only speaks English & python"], "my-key": "my-value"}) +store.put( + namespace, + "a-memory", + { + "rules": [ + "User likes short, direct language", + "User only speaks English & python", + ], + "my-key": "my-value", + }, +) # get the "memory" by ID item = store.get(namespace, "a-memory") -# list "memories" within this namespace, filtering on content equivalence -items = store.search(namespace, filter={"my-key": "my-value"}) +# search for "memories" within this namespace, filtering on content equivalence, sorted by vector similarity +items = store.search( + namespace, filter={"my-key": "my-value"}, query="language preferences" +) ``` ### Framework for thinking about long-term memory @@ -232,7 +250,7 @@ Alternatively, memories can be a collection of documents that are continuously u However, this shifts some complexity memory updating. The model must now _delete_ or _update_ existing items in the list, which can be tricky. In addition, some models may default to over-inserting and others may default to over-updating. See the [Trustcall](https://github.com/hinthornw/trustcall) package for one way to manage this and consider evaluation (e.g., with a tool like [LangSmith](https://docs.smith.langchain.com/tutorials/Developers/evaluation)) to help you tune the behavior. -Working with document collections also shifts complexity to memory **search** over the list. The `Store` currently supports [filtering by metadata](https://langchain-ai.github.io/langgraph/reference/store/#storage) and will soon add [semantic search shortly](https://python.langchain.com/docs/concepts/vectorstores/), but selecting the most relevant documents can be tricky as the list grows. +Working with document collections also shifts complexity to memory **search** over the list. The `Store` currently supports both [semantic search](https://langchain-ai.github.io/langgraph/reference/store/#langgraph.store.base.SearchOp.query) and [filtering by content](https://langchain-ai.github.io/langgraph/reference/store/#langgraph.store.base.SearchOp.filter). Finally, using a collection of memories can make it challenging to provide comprehensive context to the model. While individual memories may follow a specific schema, this structure might not capture the full context or relationships between memories. As a result, when using these memories to generate responses, the model may lack important contextual information that would be more readily available in a unified profile approach. diff --git a/docs/docs/how-tos/cross-thread-persistence.ipynb b/docs/docs/how-tos/cross-thread-persistence.ipynb index da728b24e..ac6c657f2 100644 --- a/docs/docs/how-tos/cross-thread-persistence.ipynb +++ b/docs/docs/how-tos/cross-thread-persistence.ipynb @@ -41,6 +41,9 @@ "

\n", " Support for the Store API that is used in this guide was added in LangGraph v0.2.32.\n", "

\n", + "

\n", + " Support for index and query arguments of the Store API that is used in this guide was added in LangGraph v0.2.54.\n", + "

\n", "\n", "\n", "## Setup\n", @@ -114,7 +117,7 @@ "\n", "Importantly, to determine the user, we will be passing `user_id` via the config keyword argument of the node function.\n", "\n", - "Let's first define an `InMemoryStore` which is already populated with some memories about the users." + "Let's first define an `InMemoryStore` already populated with some memories about the users." ] }, { @@ -125,8 +128,14 @@ "outputs": [], "source": [ "from langgraph.store.memory import InMemoryStore\n", + "from langchain_openai import OpenAIEmbeddings\n", "\n", - "in_memory_store = InMemoryStore()" + "in_memory_store = InMemoryStore(\n", + " index={\n", + " \"embed\": OpenAIEmbeddings(model=\"text-embedding-3-small\"),\n", + " \"dims\": 1536,\n", + " }\n", + ")" ] }, { @@ -163,7 +172,7 @@ "def call_model(state: MessagesState, config: RunnableConfig, *, store: BaseStore):\n", " user_id = config[\"configurable\"][\"user_id\"]\n", " namespace = (\"memories\", user_id)\n", - " memories = store.search(namespace)\n", + " memories = store.search(namespace, query=str(state[\"messages\"][-1].content))\n", " info = \"\\n\".join([d.value[\"data\"] for d in memories])\n", " system_msg = f\"You are a helpful assistant talking to the user. User info: {info}\"\n", "\n", diff --git a/docs/docs/how-tos/index.md b/docs/docs/how-tos/index.md index 1419fc1f2..f1c0f1a51 100644 --- a/docs/docs/how-tos/index.md +++ b/docs/docs/how-tos/index.md @@ -39,6 +39,7 @@ LangGraph makes it easy to manage conversation [memory](../concepts/memory.md) i - [How to manage conversation history](memory/manage-conversation-history.ipynb) - [How to delete messages](memory/delete-messages.ipynb) - [How to add summary conversation memory](memory/add-summary-conversation-history.ipynb) +- [Add long-term memory (cross-thread)](cross-thread-persistence.ipynb) ### Human-in-the-loop @@ -139,6 +140,7 @@ Learn how to set up your app for deployment to LangGraph Platform: - [How to set up app for deployment (requirements.txt)](../cloud/deployment/setup.md) - [How to set up app for deployment (pyproject.toml)](../cloud/deployment/setup_pyproject.md) - [How to set up app for deployment (JavaScript)](../cloud/deployment/setup_javascript.md) +- [How to add semantic search](../cloud/deployment/semantic_search.md) - [How to customize Dockerfile](../cloud/deployment/custom_docker.md) - [How to test locally](../cloud/deployment/test_locally.md) - [How to rebuild graph at runtime](../cloud/deployment/graph_rebuild.md) diff --git a/libs/checkpoint-postgres/langgraph/store/postgres/aio.py b/libs/checkpoint-postgres/langgraph/store/postgres/aio.py index 282f08186..9be44ded6 100644 --- a/libs/checkpoint-postgres/langgraph/store/postgres/aio.py +++ b/libs/checkpoint-postgres/langgraph/store/postgres/aio.py @@ -37,6 +37,68 @@ class AsyncPostgresStore(AsyncBatchedBaseStore, BasePostgresStore[_ainternal.Conn]): + """Asynchronous Postgres-backed store with optional vector search using pgvector. + + !!! example "Examples" + Basic setup and key-value storage: + ```python + from langgraph.store.postgres import AsyncPostgresStore + + async with AsyncPostgresStore.from_conn_string( + "postgresql://user:pass@localhost:5432/dbname" + ) as store: + await store.setup() + + # Store and retrieve data + await store.aput(("users", "123"), "prefs", {"theme": "dark"}) + item = await store.aget(("users", "123"), "prefs") + ``` + + Vector search using LangChain embeddings: + ```python + from langchain.embeddings import init_embeddings + from langgraph.store.postgres import AsyncPostgresStore + + async with AsyncPostgresStore.from_conn_string( + "postgresql://user:pass@localhost:5432/dbname", + index={ + "dims": 1536, + "embed": init_embeddings("openai:text-embedding-3-small"), + "fields": ["text"] # specify which fields to embed. Default is the whole serialized value + } + ) as store: + await store.setup() # Do this once to run migrations + + # Store documents + await store.aput(("docs",), "doc1", {"text": "Python tutorial"}) + await store.aput(("docs",), "doc2", {"text": "TypeScript guide"}) + + # Search by similarity + results = await store.asearch(("docs",), query="python programming") + ``` + + Using connection pooling for better performance: + ```python + from langgraph.store.postgres import AsyncPostgresStore, PoolConfig + + async with AsyncPostgresStore.from_conn_string( + "postgresql://user:pass@localhost:5432/dbname", + pool_config=PoolConfig( + min_size=5, + max_size=20 + ) + ) as store: + await store.setup() + # Use store with connection pooling... + ``` + + Warning: + Make sure to: + 1. Call `setup()` before first use to create necessary tables and indexes + 2. Have the pgvector extension available to use vector search + 3. Use Python 3.10+ for async functionality + """ + __slots__ = ( "_deserializer", "pipe", diff --git a/libs/checkpoint-postgres/langgraph/store/postgres/base.py b/libs/checkpoint-postgres/langgraph/store/postgres/base.py index 28edd8998..e12a59667 100644 --- a/libs/checkpoint-postgres/langgraph/store/postgres/base.py +++ b/libs/checkpoint-postgres/langgraph/store/postgres/base.py @@ -534,6 +534,52 @@ def _get_filter_condition(self, key: str, op: str, value: Any) -> tuple[str, lis class PostgresStore(BaseStore, BasePostgresStore[_pg_internal.Conn]): + """Postgres-backed store with optional vector search using pgvector. + + !!! example "Examples" + Basic setup and key-value storage: + ```python + from langgraph.store.postgres import PostgresStore + + store = PostgresStore( + connection_string="postgresql://user:pass@localhost:5432/dbname" + ) + store.setup() + + # Store and retrieve data + store.put(("users", "123"), "prefs", {"theme": "dark"}) + item = store.get(("users", "123"), "prefs") + ``` + + Vector search using LangChain embeddings: + ```python + from langchain.embeddings import init_embeddings + from langgraph.store.postgres import PostgresStore + + store = PostgresStore( + connection_string="postgresql://user:pass@localhost:5432/dbname", + index={ + "dims": 1536, + "embed": init_embeddings("openai:text-embedding-3-small"), + "fields": ["text"] # specify which fields to embed. Default is the whole serialized value + } + ) + store.setup() # Do this once to run migrations + + # Store documents + store.put(("docs",), "doc1", {"text": "Python tutorial"}) + store.put(("docs",), "doc2", {"text": "TypeScript guide"}) + + # Search by similarity + results = store.search(("docs",), query="python programming") + ``` + + Warning: + Make sure to call `setup()` before first use to create necessary tables and indexes. + The pgvector extension must be available to use vector search. + + """ + __slots__ = ( "_deserializer", "pipe", diff --git a/libs/checkpoint/langgraph/store/base/__init__.py b/libs/checkpoint/langgraph/store/base/__init__.py index 033cfba12..9673fc6cb 100644 --- a/libs/checkpoint/langgraph/store/base/__init__.py +++ b/libs/checkpoint/langgraph/store/base/__init__.py @@ -4,9 +4,9 @@ Supports hierarchical namespaces, key-value storage, and optional vector search. Core types: -- BaseStore: Store interface with sync/async operations -- Item: Stored key-value pairs with metadata -- Op: Get/Put/Search/List operations + - BaseStore: Store interface with sync/async operations + - Item: Stored key-value pairs with metadata + - Op: Get/Put/Search/List operations """ from abc import ABC, abstractmethod @@ -89,7 +89,7 @@ def dict(self) -> dict: class SearchItem(Item): - """Represents a result item with additional response metadata.""" + """Represents an item returned from a search operation with additional metadata.""" __slots__ = ("score",) @@ -133,7 +133,7 @@ class GetOp(NamedTuple): This operation allows precise retrieval of stored items using their full path (namespace) and unique identifier (key) combination. - ??? example "Examples" + ???+example "Examples" Basic item retrieval: ```python @@ -145,7 +145,7 @@ class GetOp(NamedTuple): namespace: tuple[str, ...] """Hierarchical path that uniquely identifies the item's location. - ??? example "Examples" + ???+example "Examples" ```python ("users",) # Root level users namespace @@ -156,7 +156,7 @@ class GetOp(NamedTuple): key: str """Unique identifier for the item within its specific namespace. - ??? example "Examples" + ???+example "Examples" ```python "user123" # For a user profile @@ -175,7 +175,7 @@ class SearchOp(NamedTuple): Note: Natural language search support depends on your store implementation. - ??? example "Examples" + ???+example "Examples" Search with filters and pagination: ```python SearchOp( @@ -199,7 +199,7 @@ class SearchOp(NamedTuple): namespace_prefix: tuple[str, ...] """Hierarchical path prefix defining the search scope. - ??? example "Examples" + ???+example "Examples" ```python () # Search entire store @@ -221,8 +221,7 @@ class SearchOp(NamedTuple): - $lt: Less than - $lte: Less than or equal to - ??? example "Examples" - + ???+example "Examples" Simple exact match: ```python @@ -243,9 +242,6 @@ class SearchOp(NamedTuple): "color": "red" } ``` - - Note: - Comparison operator support depends on your store implementation. """ limit: int = 10 @@ -257,7 +253,7 @@ class SearchOp(NamedTuple): query: Optional[str] = None """Natural language search query for semantic search capabilities. - ??? example "Examples" + ???+example "Examples" - "technical documentation about REST APIs" - "machine learning papers from 2023" """ @@ -267,10 +263,12 @@ class SearchOp(NamedTuple): NamespacePath = tuple[Union[str, Literal["*"]], ...] """A tuple representing a namespace path that can include wildcards. -Examples: +???+example "Examples" + ```python ("users",) # Exact users namespace ("documents", "*") # Any sub-namespace under documents ("cache", "*", "v1") # Any cache category with v1 version + ``` """ # Type for specifying how to match namespaces @@ -290,7 +288,7 @@ class MatchCondition(NamedTuple): pattern that can include wildcards to flexibly match different namespace hierarchies. - ??? example "Examples" + ???+example "Examples" Prefix matching: ```python MatchCondition(match_type="prefix", path=("users", "profiles")) @@ -320,7 +318,7 @@ class ListNamespacesOp(NamedTuple): This operation allows exploring the organization of data, finding specific collections, and navigating the namespace hierarchy. - ??? example "Examples" + ???+example "Examples" List all namespaces under the "documents" path: ```python @@ -343,7 +341,7 @@ class ListNamespacesOp(NamedTuple): match_conditions: Optional[tuple[MatchCondition, ...]] = None """Optional conditions for filtering namespaces. - ??? example "Examples" + ???+example "Examples" All user namespaces: ```python (MatchCondition(match_type="prefix", path=("users",)),) @@ -385,7 +383,7 @@ class PutOp(NamedTuple): The namespace acts as a folder-like structure to organize items. Each element in the tuple represents one level in the hierarchy. - ??? example "Examples" + ???+example "Examples" Root level documents ```python ("documents",) @@ -447,7 +445,7 @@ class PutOp(NamedTuple): - Last element: "array[-1]" - All elements (each individually): "array[*]" - ??? example "Examples" + ???+example "Examples" - None - Use store defaults - False - Don't index this item - list[str] - List of fields to index @@ -490,7 +488,71 @@ class IndexConfig(TypedDict, total=False): """ embed: Union[Embeddings, EmbeddingsFunc, AEmbeddingsFunc] - """Optional function to generate embeddings from text.""" + """Optional function to generate embeddings from text. + + Can be specified in three ways: + 1. A LangChain Embeddings instance + 2. A synchronous embedding function (EmbeddingsFunc) + 3. An asynchronous embedding function (AEmbeddingsFunc) + + ???+example "Examples" + Using LangChain's initialization with InMemoryStore: + ```python + from langchain.embeddings import init_embeddings + from langgraph.store.memory import InMemoryStore + + store = InMemoryStore( + index={ + "dims": 1536, + "embed": init_embeddings("openai:text-embedding-3-small") + } + ) + ``` + + Using a custom embedding function with InMemoryStore: + ```python + from openai import OpenAI + from langgraph.store.memory import InMemoryStore + + client = OpenAI() + + def embed_texts(texts: list[str]) -> list[list[float]]: + response = client.embeddings.create( + model="text-embedding-3-small", + input=texts + ) + return [e.embedding for e in response.data] + + store = InMemoryStore( + index={ + "dims": 1536, + "embed": embed_texts + } + ) + ``` + + Using an asynchronous embedding function with InMemoryStore: + ```python + from openai import AsyncOpenAI + from langgraph.store.memory import InMemoryStore + + client = AsyncOpenAI() + + async def aembed_texts(texts: list[str]) -> list[list[float]]: + response = await client.embeddings.create( + model="text-embedding-3-small", + input=texts + ) + return [e.embedding for e in response.data] + + store = InMemoryStore( + index={ + "dims": 1536, + "embed": aembed_texts + } + ) + ``` + """ fields: Optional[list[str]] """Fields to extract text from for embedding generation. @@ -565,6 +627,39 @@ def search( Returns: List of items matching the search criteria. + + ???+ example "Examples" + Basic filtering: + ```python + # Search for documents with specific metadata + results = store.search( + ("docs",), + filter={"type": "article", "status": "published"} + ) + ``` + + Natural language search (requires vector store implementation): + ```python + # Initialize store with embedding configuration + store = YourStore( # e.g., InMemoryStore, AsyncPostgresStore + index={ + "dims": 1536, # embedding dimensions + "embed": your_embedding_function, # function to create embeddings + "fields": ["text"] # fields to embed + } + ) + + # Search for semantically similar documents + results = store.search( + ("docs",), + query="machine learning applications in healthcare", + filter={"type": "research_paper"}, + limit=5 + ) + ``` + + Note: Natural language search support depends on your store implementation + and requires proper embedding configuration. """ return self.batch([SearchOp(namespace_prefix, filter, limit, offset, query)])[0] @@ -596,13 +691,13 @@ def put( Indexing capabilities depend on your store implementation. Some implementations may support only a subset of indexing features. - ??? example "Examples" + ???+example "Examples" Simple storage without special indexing (respects store defaults) ```python store.put(("docs",), "report", {"title": "Annual Report"}) ``` - Index specific fields for search + Index specific fields for search (if store configured to index items) ```python store.put(("docs",), "report", {"title": "Annual Report"}, index=["title"]) ``` @@ -650,7 +745,7 @@ def list_namespaces( List[Tuple[str, ...]]: A list of namespace tuples that match the criteria. Each tuple represents a full namespace path up to `max_depth`. - ??? example "Examples": + ???+example "Examples": Setting max_depth=3. Given the namespaces: ```python # Example if you have the following namespaces: @@ -710,6 +805,39 @@ async def asearch( Returns: List of items matching the search criteria. + + ???+ example "Examples" + Basic filtering: + ```python + # Search for documents with specific metadata + results = await store.asearch( + ("docs",), + filter={"type": "article", "status": "published"} + ) + ``` + + Natural language search (requires vector store implementation): + ```python + # Initialize store with embedding configuration + store = YourStore( # e.g., InMemoryStore, AsyncPostgresStore + index={ + "dims": 1536, # embedding dimensions + "embed": your_embedding_function, # function to create embeddings + "fields": ["text"] # fields to embed + } + ) + + # Search for semantically similar documents + results = await store.asearch( + ("docs",), + query="machine learning applications in healthcare", + filter={"type": "research_paper"}, + limit=5 + ) + ``` + + Note: Natural language search support depends on your store implementation + and requires proper embedding configuration. """ return ( await self.abatch( @@ -745,13 +873,13 @@ async def aput( Indexing capabilities depend on your store implementation. Some implementations may support only a subset of indexing features. - ??? example "Examples" + ???+example "Examples" Simple storage without special indexing: ```python await store.aput(("docs",), "report", {"title": "Annual Report"}) ``` - Index specific fields for search: + Index specific fields for search (if store configured to index items): ```python await store.aput( ("docs",), @@ -802,7 +930,7 @@ async def alist_namespaces( List[Tuple[str, ...]]: A list of namespace tuples that match the criteria. Each tuple represents a full namespace path up to `max_depth`. - ??? example "Examples" + ???+example "Examples" Setting max_depth=3 with existing namespaces: ```python # Given the following namespaces: diff --git a/libs/checkpoint/langgraph/store/memory/__init__.py b/libs/checkpoint/langgraph/store/memory/__init__.py index eec511ac8..d2786db48 100644 --- a/libs/checkpoint/langgraph/store/memory/__init__.py +++ b/libs/checkpoint/langgraph/store/memory/__init__.py @@ -1,31 +1,102 @@ -"""In-memory key-value store. +"""In-memory dictionary-backed store with optional vector search. -A lightweight store implementation using Python dictionaries. Supports basic -key-value operations and vector search when configured with embeddings. - -Examples: +!!! example "Examples" Basic key-value storage: - store = InMemoryStore() - store.put(("users", "123"), "prefs", {"theme": "dark"}) - item = store.get(("users", "123"), "prefs") + ```python + from langgraph.store.memory import InMemoryStore + + store = InMemoryStore() + store.put(("users", "123"), "prefs", {"theme": "dark"}) + item = store.get(("users", "123"), "prefs") + ``` + + Vector search using LangChain embeddings: + ```python + from langchain.embeddings import init_embeddings + from langgraph.store.memory import InMemoryStore + + store = InMemoryStore( + index={ + "dims": 1536, + "embed": init_embeddings("openai:text-embedding-3-small") + } + ) + + # Store documents + store.put(("docs",), "doc1", {"text": "Python tutorial"}) + store.put(("docs",), "doc2", {"text": "TypeScript guide"}) + + # Search by similarity + results = store.search(("docs",), query="python programming") + ``` + + Vector search using OpenAI SDK directly: + ```python + from openai import OpenAI + from langgraph.store.memory import InMemoryStore + + client = OpenAI() + + def embed_texts(texts: list[str]) -> list[list[float]]: + response = client.embeddings.create( + model="text-embedding-3-small", + input=texts + ) + return [e.embedding for e in response.data] - Vector search with embeddings: - from langchain_openai import OpenAIEmbeddings - store = InMemoryStore(index={ + store = InMemoryStore( + index={ "dims": 1536, - "embed": OpenAIEmbeddings(model="text-embedding-3-small"), - }) + "embed": embed_texts + } + ) + + # Store documents + store.put(("docs",), "doc1", {"text": "Python tutorial"}) + store.put(("docs",), "doc2", {"text": "TypeScript guide"}) + + # Search by similarity + results = store.search(("docs",), query="python programming") + ``` + + Async vector search using OpenAI SDK: + ```python + from openai import AsyncOpenAI + from langgraph.store.memory import InMemoryStore + + client = AsyncOpenAI() + + async def aembed_texts(texts: list[str]) -> list[list[float]]: + response = await client.embeddings.create( + model="text-embedding-3-small", + input=texts + ) + return [e.embedding for e in response.data] + + store = InMemoryStore( + index={ + "dims": 1536, + "embed": aembed_texts + } + ) - # Store documents - store.put(("docs",), "doc1", {"text": "Python tutorial"}) - store.put(("docs",), "doc2", {"text": "TypeScript guide"}) + # Store documents + await store.aput(("docs",), "doc1", {"text": "Python tutorial"}) + await store.aput(("docs",), "doc2", {"text": "TypeScript guide"}) - # Search by similarity - results = store.search(("docs",), query="python programming") + # Search by similarity + results = await store.asearch(("docs",), query="python programming") + ``` +Warning: + This store keeps all data in memory. Data is lost when the process exits. + For persistence, use a database-backed store like PostgresStore. -Note: - For production use cases requiring persistence, use a database-backed store instead. +Tip: + For vector search, install numpy for better performance: + ```bash + pip install numpy + ``` """ import asyncio @@ -62,17 +133,18 @@ class InMemoryStore(BaseStore): """In-memory dictionary-backed store with optional vector search. - Examples: + !!! example "Examples" Basic key-value storage: store = InMemoryStore() store.put(("users", "123"), "prefs", {"theme": "dark"}) item = store.get(("users", "123"), "prefs") Vector search with embeddings: - from langchain_openai import OpenAIEmbeddings + from langchain.embeddings import init_embeddings store = InMemoryStore(index={ "dims": 1536, - "embed": OpenAIEmbeddings(model="text-embedding-3-small"), + "embed": init_embeddings("openai:text-embedding-3-small"), + "fields": ["text"], }) # Store documents diff --git a/libs/sdk-js/src/client.ts b/libs/sdk-js/src/client.ts index 14284bcff..581145229 100644 --- a/libs/sdk-js/src/client.ts +++ b/libs/sdk-js/src/client.ts @@ -1206,6 +1206,7 @@ export class StoreClient extends BaseClient { * @param options.filter Optional dictionary of key-value pairs to filter results. * @param options.limit Maximum number of items to return (default is 10). * @param options.offset Number of items to skip before returning results (default is 0). + * @param options.query Optional search query. * @returns Promise */ async searchItems( @@ -1214,6 +1215,7 @@ export class StoreClient extends BaseClient { filter?: Record; limit?: number; offset?: number; + query?: string; }, ): Promise { const payload = { @@ -1221,6 +1223,7 @@ export class StoreClient extends BaseClient { filter: options?.filter, limit: options?.limit ?? 10, offset: options?.offset ?? 0, + query: options?.query, }; const response = await this.fetch( diff --git a/libs/sdk-js/src/schema.ts b/libs/sdk-js/src/schema.ts index f68e3d42f..259bcd539 100644 --- a/libs/sdk-js/src/schema.ts +++ b/libs/sdk-js/src/schema.ts @@ -264,11 +264,6 @@ export interface Checkpoint { export interface ListNamespaceResponse { namespaces: string[][]; } - -export interface SearchItemsResponse { - items: Item[]; -} - export interface Item { namespace: string[]; key: string; @@ -276,3 +271,10 @@ export interface Item { createdAt: string; updatedAt: string; } + +export interface SearchItem extends Item { + score?: number; +} +export interface SearchItemsResponse { + items: SearchItem[]; +}