\n",
+ "
Set up LangSmith for LangGraph development
\n",
+ "
\n",
+ " Sign up for LangSmith to quickly spot issues and improve the performance of your LangGraph projects. LangSmith lets you use trace data to debug, test, and monitor your LLM apps built with LangGraph — read more about how to get started here. \n",
+ "
\n",
+ "
\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/deploy-self-hosted.md b/docs/docs/how-tos/deploy-self-hosted.md
index 5e1bf93e4..d0d3a3efe 100644
--- a/docs/docs/how-tos/deploy-self-hosted.md
+++ b/docs/docs/how-tos/deploy-self-hosted.md
@@ -17,6 +17,10 @@ You will need to do the following:
2. Build a docker image with the [LangGraph Server](../concepts/langgraph_server.md) using the [LangGraph CLI](../concepts/langgraph_cli.md).
3. Deploy a web server that will run the docker image and pass in the necessary environment variables.
+## Helm Chart
+
+If you would like to deploy LangGraph Cloud on Kubernetes, you can use this [Helm chart](https://github.com/langchain-ai/helm/blob/main/charts/langgraph-cloud/README.md).
+
## Environment Variables
You will eventually need to pass in the following environment variables to the LangGraph Deploy server:
diff --git a/docs/docs/how-tos/index.md b/docs/docs/how-tos/index.md
index 92e7b526c..8256a9adb 100644
--- a/docs/docs/how-tos/index.md
+++ b/docs/docs/how-tos/index.md
@@ -20,6 +20,7 @@ These how-to guides show how to achieve that controllability.
- [How to create branches for parallel execution](branching.ipynb)
- [How to create map-reduce branches for parallel execution](map-reduce.ipynb)
- [How to control graph recursion limit](recursion-limit.ipynb)
+- [How to combine control flow and state updates with Command](command.ipynb)
### Persistence
@@ -39,6 +40,8 @@ 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)
+- [How to add long-term memory (cross-thread)](cross-thread-persistence.ipynb)
+- [How to use semantic search for long-term memory](memory/semantic-search.ipynb)
### Human-in-the-loop
@@ -70,7 +73,7 @@ you to involve humans in the decision-making process of your graph. These how-to
### Tool calling
-[Tool calling](https://python.langchain.com/docs/concepts/tool_calling/) is a type of chat model API that accepts tool schemas, along with messages, as input and returns invocations of those tools as part of the output message.
+[Tool calling](https://python.langchain.com/docs/concepts/tool_calling/) is a type of chat model API that accepts tool schemas, along with messages, as input and returns invocations of those tools as part of the output message.
These how-to guides show common patterns for tool calling with LangGraph:
@@ -103,6 +106,7 @@ These how-to guides show common patterns for tool calling with LangGraph:
- [How to force function calling agent to structure output](react-agent-structured-output.ipynb)
- [How to pass custom LangSmith run ID for graph runs](run-id-langsmith.ipynb)
- [How to return state before hitting recursion limit](return-when-recursion-limit-hits.ipynb)
+- [How to integrate LangGraph with AutoGen, CrewAI, and other frameworks](autogen-integration.ipynb)
### Prebuilt ReAct Agent
@@ -117,12 +121,13 @@ These guides show how to use the prebuilt ReAct agent:
- [How to add a custom system prompt to a ReAct agent](create-react-agent-system-prompt.ipynb)
- [How to add human-in-the-loop processes to a ReAct agent](create-react-agent-hitl.ipynb)
- [How to create prebuilt ReAct agent from scratch](react-agent-from-scratch.ipynb)
+- [How to add semantic search for long-term memory to a ReAct agent](memory/semantic-search.ipynb#using-in-create-react-agent)
## LangGraph Platform
This section includes how-to guides for LangGraph Platform.
-LangGraph Platform is a commercial solution for deploying agentic applications in production, built on the open-source LangGraph framework.
+LangGraph Platform is a commercial solution for deploying agentic applications in production, built on the open-source LangGraph framework.
The LangGraph Platform offers a few different deployment options described in the [deployment options guide](../concepts/deployment_options.md).
@@ -138,9 +143,11 @@ 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)
+- [How to use LangGraph Platform to deploy CrewAI, AutoGen, and other frameworks](autogen-langgraph-platform.ipynb)
### Deployment
@@ -148,7 +155,8 @@ LangGraph applications can be deployed using LangGraph Cloud, which provides a r
- [How to deploy to LangGraph cloud](../cloud/deployment/cloud.md)
- [How to deploy to a self-hosted environment](./deploy-self-hosted.md)
-- [How to interact with the deployment using RemoteGraph](./use-remote-graph.md)
+- [How to interact with the deployment using RemoteGraph](./use-remote-graph.md)
+
### Assistants
[Assistants](../concepts/assistants.md) is a configured instance of a template.
@@ -163,7 +171,7 @@ LangGraph applications can be deployed using LangGraph Cloud, which provides a r
### Runs
-LangGraph Cloud supports multiple types of runs besides streaming runs.
+LangGraph Platform supports multiple types of runs besides streaming runs.
- [How to run an agent in the background](../cloud/how-tos/background_run.md)
- [How to run multiple agents in the same thread](../cloud/how-tos/same-thread.md)
@@ -183,7 +191,7 @@ Streaming the results of your LLM application is vital for ensuring a good user
### Human-in-the-loop
-When creating complex graphs, leaving every decision up to the LLM can be dangerous, especially when the decisions involve invoking certain tools or accessing specific documents. To remedy this, LangGraph allows you to insert human-in-the-loop behavior to ensure your graph does not have undesired outcomes. Read more about the different ways you can add human-in-the-loop capabilities to your LangGraph Cloud projects in these how-to guides:
+When designing complex graphs, relying entirely on the LLM for decision-making can be risky, particularly when it involves tools that interact with files, APIs, or databases. These interactions may lead to unintended data access or modifications, depending on the use case. To mitigate these risks, LangGraph allows you to integrate human-in-the-loop behavior, ensuring your LLM applications operate as intended without undesirable outcomes.
- [How to add a breakpoint](../cloud/how-tos/human_in_the_loop_breakpoint.md)
- [How to wait for user input](../cloud/how-tos/human_in_the_loop_user_input.md)
@@ -193,7 +201,7 @@ When creating complex graphs, leaving every decision up to the LLM can be danger
### Double-texting
-Graph execution can take a while, and sometimes users may change their mind about the input they wanted to send before their original input has finished running. For example, a user might notice a typo in their original request and will edit the prompt and resend it. Deciding what to do in these cases is important for ensuring a smooth user experience and preventing your graphs from behaving in unexpected ways. The following how-to guides provide information on the various options LangGraph Cloud gives you for dealing with double-texting:
+Graph execution can take a while, and sometimes users may change their mind about the input they wanted to send before their original input has finished running. For example, a user might notice a typo in their original request and will edit the prompt and resend it. Deciding what to do in these cases is important for ensuring a smooth user experience and preventing your graphs from behaving in unexpected ways.
- [How to use the interrupt option](../cloud/how-tos/interrupt_concurrent.md)
- [How to use the rollback option](../cloud/how-tos/rollback_concurrent.md)
@@ -213,8 +221,9 @@ Graph execution can take a while, and sometimes users may change their mind abou
LangGraph Studio is a built-in UI for visualizing, testing, and debugging your agents.
- [How to connect to a LangGraph Cloud deployment](../cloud/how-tos/test_deployment.md)
-- [How to connect to a local deployment](../cloud/how-tos/test_local_deployment.md)
-- [How to test your graph in LangGraph Studio](../cloud/how-tos/invoke_studio.md)
+- [How to connect to a local dev server](../how-tos/local-studio.md)
+- [How to connect to a local deployment (Docker)](../cloud/how-tos/test_local_deployment.md)
+- [How to test your graph in LangGraph Studio (MacOS only)](../cloud/how-tos/invoke_studio.md)
- [How to interact with threads in LangGraph Studio](../cloud/how-tos/threads_studio.md)
## Troubleshooting
@@ -226,5 +235,3 @@ These are the guides for resolving common errors you may find while building wit
- [INVALID_GRAPH_NODE_RETURN_VALUE](../troubleshooting/errors/INVALID_GRAPH_NODE_RETURN_VALUE.md)
- [MULTIPLE_SUBGRAPHS](../troubleshooting/errors/MULTIPLE_SUBGRAPHS.md)
- [INVALID_CHAT_HISTORY](../troubleshooting/errors/INVALID_CHAT_HISTORY.md)
-
-
diff --git a/docs/docs/how-tos/memory/semantic-search.ipynb b/docs/docs/how-tos/memory/semantic-search.ipynb
new file mode 100644
index 000000000..8e7a8d057
--- /dev/null
+++ b/docs/docs/how-tos/memory/semantic-search.ipynb
@@ -0,0 +1,532 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# How to add semantic search to your agent's memory\n",
+ "\n",
+ "This guide shows how to enable semantic search in your agent's memory store. This lets search for items in the store by semantic similarity.\n",
+ "\n",
+ "!!! tip Prerequisites\n",
+ " This guide assumes familiarity with the [memory in LangGraph](https://langchain-ai.github.io/langgraph/concepts/memory/).\n",
+ "\n",
+ "First, install this guide's prerequisites."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%%capture --no-stderr\n",
+ "%pip install -U langgraph langchain-openai langchain"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import getpass\n",
+ "import os\n",
+ "\n",
+ "\n",
+ "def _set_env(var: str):\n",
+ " if not os.environ.get(var):\n",
+ " os.environ[var] = getpass.getpass(f\"{var}: \")\n",
+ "\n",
+ "\n",
+ "_set_env(\"OPENAI_API_KEY\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Next, create the store with an [index configuration](https://langchain-ai.github.io/langgraph/reference/store/#langgraph.store.base.IndexConfig). By default, stores are configured without semantic/vector search. You can opt in to indexing items when creating the store by providing an [IndexConfig](https://langchain-ai.github.io/langgraph/reference/store/#langgraph.store.base.IndexConfig) to the store's constructor. If your store class does not implement this interface, or if you do not pass in an index configuration, semantic search is disabled, and all `index` arguments passed to `put` or `aput` will have no effect. Below is an example."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/var/folders/gf/6rnp_mbx5914kx7qmmh7xzmw0000gn/T/ipykernel_83572/2318027494.py:5: LangChainBetaWarning: The function `init_embeddings` is in beta. It is actively being worked on, so the API may change.\n",
+ " embeddings = init_embeddings(\"openai:text-embedding-3-small\")\n"
+ ]
+ }
+ ],
+ "source": [
+ "from langchain.embeddings import init_embeddings\n",
+ "from langgraph.store.memory import InMemoryStore\n",
+ "\n",
+ "# Create store with semantic search enabled\n",
+ "embeddings = init_embeddings(\"openai:text-embedding-3-small\")\n",
+ "store = InMemoryStore(\n",
+ " index={\n",
+ " \"embed\": embeddings,\n",
+ " \"dims\": 1536,\n",
+ " }\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now let's store some memories:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Store some memories\n",
+ "store.put((\"user_123\", \"memories\"), \"1\", {\"text\": \"I love pizza\"})\n",
+ "store.put((\"user_123\", \"memories\"), \"2\", {\"text\": \"I prefer Italian food\"})\n",
+ "store.put((\"user_123\", \"memories\"), \"3\", {\"text\": \"I don't like spicy food\"})\n",
+ "store.put((\"user_123\", \"memories\"), \"3\", {\"text\": \"I am studying econometrics\"})\n",
+ "store.put((\"user_123\", \"memories\"), \"3\", {\"text\": \"I am a plumber\"})"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Search memories using natural language:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Memory: I prefer Italian food (similarity: 0.46482669521168163)\n",
+ "Memory: I love pizza (similarity: 0.35514845174380766)\n",
+ "Memory: I am a plumber (similarity: 0.155698702336571)\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Find memories about food preferences\n",
+ "memories = store.search((\"user_123\", \"memories\"), query=\"I like food?\", limit=5)\n",
+ "\n",
+ "for memory in memories:\n",
+ " print(f'Memory: {memory.value[\"text\"]} (similarity: {memory.score})')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Using in your agent\n",
+ "\n",
+ "Add semantic search to any node by injecting the store."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "What are you in the mood for? Since you love Italian food and pizza, would you like to order a pizza or try making one at home?"
+ ]
+ }
+ ],
+ "source": [
+ "from typing import Optional\n",
+ "\n",
+ "from langchain.chat_models import init_chat_model\n",
+ "from langgraph.store.base import BaseStore\n",
+ "\n",
+ "from langgraph.graph import START, MessagesState, StateGraph\n",
+ "\n",
+ "llm = init_chat_model(\"openai:gpt-4o-mini\")\n",
+ "\n",
+ "\n",
+ "def chat(state, *, store: BaseStore):\n",
+ " # Search based on user's last message\n",
+ " items = store.search(\n",
+ " (\"user_123\", \"memories\"), query=state[\"messages\"][-1].content, limit=2\n",
+ " )\n",
+ " memories = \"\\n\".join(item.value[\"text\"] for item in items)\n",
+ " memories = f\"## Memories of user\\n{memories}\" if memories else \"\"\n",
+ " response = llm.invoke(\n",
+ " [\n",
+ " {\"role\": \"system\", \"content\": f\"You are a helpful assistant.\\n{memories}\"},\n",
+ " *state[\"messages\"],\n",
+ " ]\n",
+ " )\n",
+ " return {\"messages\": [response]}\n",
+ "\n",
+ "\n",
+ "builder = StateGraph(MessagesState)\n",
+ "builder.add_node(chat)\n",
+ "builder.add_edge(START, \"chat\")\n",
+ "graph = builder.compile(store=store)\n",
+ "\n",
+ "for message, metadata in graph.stream(\n",
+ " input={\"messages\": [{\"role\": \"user\", \"content\": \"I'm hungry\"}]},\n",
+ " stream_mode=\"messages\",\n",
+ "):\n",
+ " print(message.content, end=\"\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Using in `create_react_agent`\n",
+ "\n",
+ "Add semantic search to your tool calling agent by injecting the store in the `state_modifier`. You can also use the store in a tool to let your agent manually store or search for memories."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import uuid\n",
+ "from typing import Optional\n",
+ "\n",
+ "from langchain.chat_models import init_chat_model\n",
+ "from langchain_core.tools import InjectedToolArg\n",
+ "from langgraph.store.base import BaseStore\n",
+ "from typing_extensions import Annotated\n",
+ "\n",
+ "from langgraph.prebuilt import create_react_agent\n",
+ "\n",
+ "\n",
+ "def prepare_messages(state, *, store: BaseStore):\n",
+ " # Search based on user's last message\n",
+ " items = store.search(\n",
+ " (\"user_123\", \"memories\"), query=state[\"messages\"][-1].content, limit=2\n",
+ " )\n",
+ " memories = \"\\n\".join(item.value[\"text\"] for item in items)\n",
+ " memories = f\"## Memories of user\\n{memories}\" if memories else \"\"\n",
+ " return [\n",
+ " {\"role\": \"system\", \"content\": f\"You are a helpful assistant.\\n{memories}\"}\n",
+ " ] + state[\"messages\"]\n",
+ "\n",
+ "\n",
+ "# You can also use the store directly within a tool!\n",
+ "def upsert_memory(\n",
+ " content: str,\n",
+ " *,\n",
+ " memory_id: Optional[uuid.UUID] = None,\n",
+ " store: Annotated[BaseStore, InjectedToolArg],\n",
+ "):\n",
+ " \"\"\"Upsert a memory in the database.\"\"\"\n",
+ " # The LLM can use this tool to store a new memory\n",
+ " mem_id = memory_id or uuid.uuid4()\n",
+ " store.put(\n",
+ " (\"user_123\", \"memories\"),\n",
+ " key=str(mem_id),\n",
+ " value={\"text\": content},\n",
+ " )\n",
+ " return f\"Stored memory {mem_id}\"\n",
+ "\n",
+ "\n",
+ "agent = create_react_agent(\n",
+ " init_chat_model(\"openai:gpt-4o-mini\"),\n",
+ " tools=[upsert_memory],\n",
+ " # The state_modifier is run to prepare the messages for the LLM. It is called\n",
+ " # right before each LLM call\n",
+ " state_modifier=prepare_messages,\n",
+ " store=store,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "What are you in the mood for? Since you love Italian food and pizza, maybe something in that realm would be great! Would you like suggestions for a specific dish or restaurant?"
+ ]
+ }
+ ],
+ "source": [
+ "for message, metadata in agent.stream(\n",
+ " input={\"messages\": [{\"role\": \"user\", \"content\": \"I'm hungry\"}]},\n",
+ " stream_mode=\"messages\",\n",
+ "):\n",
+ " print(message.content, end=\"\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Advanced Usage\n",
+ "\n",
+ "#### Multi-vector indexing\n",
+ "\n",
+ "Store and search different aspects of memories separately to improve recall or omit certain fields from being indexed."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Expect mem 2\n",
+ "Item: mem2; Score (0.5895009051396596)\n",
+ "Memory: Ate alone at home\n",
+ "Emotion: felt a bit lonely\n",
+ "\n",
+ "Expect mem1\n",
+ "Item: mem1; Score (0.6207546534134083)\n",
+ "Memory: Had pizza with friends at Mario's\n",
+ "Emotion: felt happy and connected\n",
+ "\n",
+ "Expect random lower score (ravioli not indexed)\n",
+ "Item: mem1; Score (0.2686278787315685)\n",
+ "Memory: Had pizza with friends at Mario's\n",
+ "Emotion: felt happy and connected\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Configure store to embed both memory content and emotional context\n",
+ "store = InMemoryStore(\n",
+ " index={\"embed\": embeddings, \"dims\": 1536, \"fields\": [\"memory\", \"emotional_context\"]}\n",
+ ")\n",
+ "# Store memories with different content/emotion pairs\n",
+ "store.put(\n",
+ " (\"user_123\", \"memories\"),\n",
+ " \"mem1\",\n",
+ " {\n",
+ " \"memory\": \"Had pizza with friends at Mario's\",\n",
+ " \"emotional_context\": \"felt happy and connected\",\n",
+ " \"this_isnt_indexed\": \"I prefer ravioli though\",\n",
+ " },\n",
+ ")\n",
+ "store.put(\n",
+ " (\"user_123\", \"memories\"),\n",
+ " \"mem2\",\n",
+ " {\n",
+ " \"memory\": \"Ate alone at home\",\n",
+ " \"emotional_context\": \"felt a bit lonely\",\n",
+ " \"this_isnt_indexed\": \"I like pie\",\n",
+ " },\n",
+ ")\n",
+ "\n",
+ "# Search focusing on emotional state - matches mem2\n",
+ "results = store.search(\n",
+ " (\"user_123\", \"memories\"), query=\"times they felt isolated\", limit=1\n",
+ ")\n",
+ "print(\"Expect mem 2\")\n",
+ "for r in results:\n",
+ " print(f\"Item: {r.key}; Score ({r.score})\")\n",
+ " print(f\"Memory: {r.value['memory']}\")\n",
+ " print(f\"Emotion: {r.value['emotional_context']}\\n\")\n",
+ "\n",
+ "# Search focusing on social eating - matches mem1\n",
+ "print(\"Expect mem1\")\n",
+ "results = store.search((\"user_123\", \"memories\"), query=\"fun pizza\", limit=1)\n",
+ "for r in results:\n",
+ " print(f\"Item: {r.key}; Score ({r.score})\")\n",
+ " print(f\"Memory: {r.value['memory']}\")\n",
+ " print(f\"Emotion: {r.value['emotional_context']}\\n\")\n",
+ "\n",
+ "print(\"Expect random lower score (ravioli not indexed)\")\n",
+ "results = store.search((\"user_123\", \"memories\"), query=\"ravioli\", limit=1)\n",
+ "for r in results:\n",
+ " print(f\"Item: {r.key}; Score ({r.score})\")\n",
+ " print(f\"Memory: {r.value['memory']}\")\n",
+ " print(f\"Emotion: {r.value['emotional_context']}\\n\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Override fields at storage time\n",
+ "You can override which fields to embed when storing a specific memory using `put(..., index=[...fields])`, regardless of the store's default configuration."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Expect mem1\n",
+ "Item: mem1; Score (0.3374968677940555)\n",
+ "Memory: I love spicy food\n",
+ "Context: At a Thai restaurant\n",
+ "\n",
+ "Expect mem2\n",
+ "Item: mem2; Score (0.36784461593247436)\n",
+ "Memory: The restaurant was too loud\n",
+ "Context: Dinner at an Italian place\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "store = InMemoryStore(\n",
+ " index={\n",
+ " \"embed\": embeddings,\n",
+ " \"dims\": 1536,\n",
+ " \"fields\": [\"memory\"],\n",
+ " } # Default to embed memory field\n",
+ ")\n",
+ "\n",
+ "# Store one memory with default indexing\n",
+ "store.put(\n",
+ " (\"user_123\", \"memories\"),\n",
+ " \"mem1\",\n",
+ " {\"memory\": \"I love spicy food\", \"context\": \"At a Thai restaurant\"},\n",
+ ")\n",
+ "\n",
+ "# Store another overriding which fields to embed\n",
+ "store.put(\n",
+ " (\"user_123\", \"memories\"),\n",
+ " \"mem2\",\n",
+ " {\"memory\": \"The restaurant was too loud\", \"context\": \"Dinner at an Italian place\"},\n",
+ " index=[\"context\"], # Override: only embed the context\n",
+ ")\n",
+ "\n",
+ "# Search about food - matches mem1 (using default field)\n",
+ "print(\"Expect mem1\")\n",
+ "results = store.search(\n",
+ " (\"user_123\", \"memories\"), query=\"what food do they like\", limit=1\n",
+ ")\n",
+ "for r in results:\n",
+ " print(f\"Item: {r.key}; Score ({r.score})\")\n",
+ " print(f\"Memory: {r.value['memory']}\")\n",
+ " print(f\"Context: {r.value['context']}\\n\")\n",
+ "\n",
+ "# Search about restaurant atmosphere - matches mem2 (using overridden field)\n",
+ "print(\"Expect mem2\")\n",
+ "results = store.search(\n",
+ " (\"user_123\", \"memories\"), query=\"restaurant environment\", limit=1\n",
+ ")\n",
+ "for r in results:\n",
+ " print(f\"Item: {r.key}; Score ({r.score})\")\n",
+ " print(f\"Memory: {r.value['memory']}\")\n",
+ " print(f\"Context: {r.value['context']}\\n\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Disable Indexing for Specific Memories\n",
+ "\n",
+ "Some memories shouldn't be searchable by content. You can disable indexing for these while still storing them using \n",
+ "`put(..., index=False)`. Example:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Expect mem1\n",
+ "Item: mem1; Score (0.32269984224327286)\n",
+ "Memory: I love chocolate ice cream\n",
+ "Type: preference\n",
+ "\n",
+ "Expect low score (mem2 not indexed)\n",
+ "Item: mem1; Score (0.010241633698527089)\n",
+ "Memory: I love chocolate ice cream\n",
+ "Type: preference\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "store = InMemoryStore(index={\"embed\": embeddings, \"dims\": 1536, \"fields\": [\"memory\"]})\n",
+ "\n",
+ "# Store a normal indexed memory\n",
+ "store.put(\n",
+ " (\"user_123\", \"memories\"),\n",
+ " \"mem1\",\n",
+ " {\"memory\": \"I love chocolate ice cream\", \"type\": \"preference\"},\n",
+ ")\n",
+ "\n",
+ "# Store a system memory without indexing\n",
+ "store.put(\n",
+ " (\"user_123\", \"memories\"),\n",
+ " \"mem2\",\n",
+ " {\"memory\": \"User completed onboarding\", \"type\": \"system\"},\n",
+ " index=False, # Disable indexing entirely\n",
+ ")\n",
+ "\n",
+ "# Search about food preferences - finds mem1\n",
+ "print(\"Expect mem1\")\n",
+ "results = store.search((\"user_123\", \"memories\"), query=\"what food preferences\", limit=1)\n",
+ "for r in results:\n",
+ " print(f\"Item: {r.key}; Score ({r.score})\")\n",
+ " print(f\"Memory: {r.value['memory']}\")\n",
+ " print(f\"Type: {r.value['type']}\\n\")\n",
+ "\n",
+ "# Search about onboarding - won't find mem2 (not indexed)\n",
+ "print(\"Expect low score (mem2 not indexed)\")\n",
+ "results = store.search((\"user_123\", \"memories\"), query=\"onboarding status\", limit=1)\n",
+ "for r in results:\n",
+ " print(f\"Item: {r.key}; Score ({r.score})\")\n",
+ " print(f\"Memory: {r.value['memory']}\")\n",
+ " print(f\"Type: {r.value['type']}\\n\")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.11.2"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/docs/docs/reference/types.md b/docs/docs/reference/types.md
index 347a87d6e..b42b11f35 100644
--- a/docs/docs/reference/types.md
+++ b/docs/docs/reference/types.md
@@ -13,3 +13,5 @@
- PregelExecutableTask
- StateSnapshot
- Send
+ - Command
+ - interrupt
diff --git a/docs/docs/tutorials/index.md b/docs/docs/tutorials/index.md
index 887740e6a..286137479 100644
--- a/docs/docs/tutorials/index.md
+++ b/docs/docs/tutorials/index.md
@@ -6,25 +6,24 @@ title: Tutorials
# Tutorials
-Welcome to the LangGraph Tutorials! These notebooks introduce LangGraph through building various language agents and applications.
+New to LangGraph or LLM app development? Read this material to get up and running building your first applications.
-## Quick Start
+## Get Started 🚀 {#quick-start}
-Learn the basics of LangGraph through a comprehensive quick start in which you will build an agent from scratch.
+- [LangGraph Quickstart](introduction.ipynb): Build a chatbot that can use tools and keep track of conversation history. Add human-in-the-loop capabilities and explore how time-travel works.
+- [LangGraph Server Quickstart](langgraph-platform/local-server.md): Launch a LangGraph server locally and interact with it using the REST API and LangGraph Studio Web UI.
+- [LangGraph Cloud QuickStart](../cloud/quick_start.md): Deploy a LangGraph app using LangGraph Cloud.
+- [LangGraph Template Quickstart](../concepts/template_applications.md): Quickly start building with LangGraph Platform using a template application.
-- [Quick Start](introduction.ipynb): In this tutorial, you will build a support chatbot using LangGraph.
-- [LangGraph Cloud Quick Start](../cloud/quick_start.md): In this tutorial, you will build and deploy an agent to LangGraph Cloud.
+## Use cases 🛠️
-## Use cases
-
-Learn from example implementations of graphs designed for specific scenarios and that implement common design patterns.
+Explore practical implementations tailored for specific scenarios:
### Chatbots
-- [Customer Support](customer-support/customer-support.ipynb): Build a customer support chatbot to manage flights, hotel reservations, car rentals, and other tasks
-- [Prompt Generation from User Requirements](chatbots/information-gather-prompting.ipynb): Build an information gathering chatbot
-- [Code Assistant](code_assistant/langgraph_code_assistant.ipynb): Build a code analysis and generation assistant
-
+- [Customer Support](customer-support/customer-support.ipynb): Build a multi-functional support bot for flights, hotels, and car rentals.
+- [Prompt Generation from User Requirements](chatbots/information-gather-prompting.ipynb): Build an information gathering chatbot.
+- [Code Assistant](code_assistant/langgraph_code_assistant.ipynb): Build a code analysis and generation assistant.
### RAG
diff --git a/docs/docs/tutorials/introduction.ipynb b/docs/docs/tutorials/introduction.ipynb
index f37fcf138..2139b6d46 100644
--- a/docs/docs/tutorials/introduction.ipynb
+++ b/docs/docs/tutorials/introduction.ipynb
@@ -5,21 +5,21 @@
"id": "4a1aae78-88a6-4133-b905-7e46c8e3772f",
"metadata": {},
"source": [
- "# LangGraph Quick Start\n",
+ "# 🚀 LangGraph Quick Start\n",
"\n",
- "In this comprehensive quick start, we will build a support chatbot in LangGraph that can:\n",
+ "In this tutorial, we will build a support chatbot in LangGraph that can:\n",
"\n",
- "- Answer common questions by searching the web\n",
- "- Maintain conversation state across calls\n",
- "- Route complex queries to a human for review\n",
- "- Use custom state to control its behavior\n",
- "- Rewind and explore alternative conversation paths\n",
+ "✅ **Answer common questions** by searching the web \n",
+ "✅ **Maintain conversation state** across calls \n",
+ "✅ **Route complex queries** to a human for review \n",
+ "✅ **Use custom state** to control its behavior \n",
+ "✅ **Rewind and explore** alternative conversation paths \n",
"\n",
- "We'll start with a basic chatbot and progressively add more sophisticated capabilities, introducing key LangGraph concepts along the way.\n",
+ "We'll start with a **basic chatbot** and progressively add more sophisticated capabilities, introducing key LangGraph concepts along the way. Let’s dive in! 🌟\n",
"\n",
"## Setup\n",
"\n",
- "First, install the required packages:"
+ "First, install the required packages and configure your environment:"
]
},
{
@@ -33,14 +33,6 @@
"%pip install -U langgraph langsmith langchain_anthropic"
]
},
- {
- "cell_type": "markdown",
- "id": "a6d1e870-1bc0-4d44-86c0-96681ccf6113",
- "metadata": {},
- "source": [
- "Next, set your API keys:"
- ]
- },
{
"cell_type": "code",
"execution_count": 2,
@@ -120,27 +112,24 @@
]
},
{
+ "attachments": {},
"cell_type": "markdown",
- "id": "31c755cd-8994-4867-bdff-96a55d7beae7",
+ "id": "c08c41da-0855-49d3-9a3d-b7eb94413367",
"metadata": {},
"source": [
- "\n",
- "
Note
\n",
- "
\n",
- " The first thing you do when you define a graph is define the State of the graph. The State consists of the schema of the graph as well as reducer functions which specify how to apply updates to the state. In our example State is a TypedDict with a single key: messages. The messages key is annotated with the add_messages reducer function, which tells LangGraph to append new messages to the existing list, rather than overwriting it. State keys without an annotation will be overwritten by each update, storing the most recent value. Check out this conceptual guide to learn more about state, reducers and other low-level concepts.\n",
- "
\n",
- "
Get API Keys
+
+