rename files

Author: lnhsingh

src/oss/GRAPH_RECURSION_LIMIT.mdx

@@ -0,0 +1,63 @@
+---
+title: GRAPH_RECURSION_LIMIT
+---
+Your LangGraph [`StateGraph`](https://langchain-ai.github.io/langgraph/reference/graphs/#langgraph.graph.state.StateGraph) reached the maximum number of steps before hitting a stop condition.
+This is often due to an infinite loop caused by code like the example below:
+
+:::python
+```python
+class State(TypedDict):
+    some_key: str
+
+builder = StateGraph(State)
+builder.add_node("a", ...)
+builder.add_node("b", ...)
+builder.add_edge("a", "b")
+builder.add_edge("b", "a")
+...
+
+graph = builder.compile()
+```
+:::
+
+:::js
+```typescript
+import { StateGraph } from "@langchain/langgraph";
+import { z } from "zod";
+
+const State = z.object({
+  someKey: z.string(),
+});
+
+const builder = new StateGraph(State)
+  .addNode("a", ...)
+  .addNode("b", ...)
+  .addEdge("a", "b")
+  .addEdge("b", "a")
+  ...
+
+const graph = builder.compile();
+```
+:::
+
+However, complex graphs may hit the default limit naturally.
+
+## Troubleshooting
+
+* If you are not expecting your graph to go through many iterations, you likely have a cycle. Check your logic for infinite loops.
+
+:::python
+* If you have a complex graph, you can pass in a higher `recursion_limit` value into your `config` object when invoking your graph like this:
+
+```python
+graph.invoke({...}, {"recursion_limit": 100})
+```
+:::
+
+:::js
+* If you have a complex graph, you can pass in a higher `recursionLimit` value into your `config` object when invoking your graph like this:
+
+```typescript
+await graph.invoke({...}, { recursionLimit: 100 });
+```
+:::

src/oss/INVALID_CHAT_HISTORY.mdx

@@ -0,0 +1,59 @@
+---
+title: INVALID_CHAT_HISTORY
+---
+:::python
+This error is raised in the prebuilt @[create_react_agent][create_react_agent] when the `call_model` graph node receives a malformed list of messages. Specifically, it is malformed when there are `AIMessages` with `tool_calls` (LLM requesting to call a tool) that do not have a corresponding `ToolMessage` (result of a tool invocation to return to the LLM).
+:::
+
+:::js
+This error is raised in the prebuilt @[createReactAgent][create_react_agent] when the `callModel` graph node receives a malformed list of messages. Specifically, it is malformed when there are `AIMessage`s with `tool_calls` (LLM requesting to call a tool) that do not have a corresponding `ToolMessage` (result of a tool invocation to return to the LLM).
+:::
+
+There could be a few reasons you're seeing this error:
+
+:::python
+1. You manually passed a malformed list of messages when invoking the graph, e.g. `graph.invoke({'messages': [AIMessage(..., tool_calls=[...])]})`
+2. The graph was interrupted before receiving updates from the `tools` node (i.e. a list of ToolMessages)
+  and you invoked it with an input that is not None or a ToolMessage,
+  e.g. `graph.invoke({'messages': [HumanMessage(...)]}, config)`.
+  This interrupt could have been triggered in one of the following ways:
+  * You manually set `interrupt_before = ['tools']` in `create_react_agent`
+  * One of the tools raised an error that wasn't handled by the @[ToolNode][ToolNode] (`"tools"`)
+:::
+
+:::js
+1. You manually passed a malformed list of messages when invoking the graph, e.g. `graph.invoke({messages: [new AIMessage({..., tool_calls: [...]})]})`
+2. The graph was interrupted before receiving updates from the `tools` node (i.e. a list of ToolMessages)
+  and you invoked it with an input that is not null or a ToolMessage,
+  e.g. `graph.invoke({messages: [new HumanMessage(...)]}, config)`.
+  This interrupt could have been triggered in one of the following ways:
+  * You manually set `interruptBefore: ['tools']` in `createReactAgent`
+  * One of the tools raised an error that wasn't handled by the @[ToolNode][ToolNode] (`"tools"`)
+:::
+
+## Troubleshooting
+
+To resolve this, you can do one of the following:
+
+1. Don't invoke the graph with a malformed list of messages
+2. In case of an interrupt (manual or due to an error) you can:
+
+:::python
+* provide ToolMessages that match existing tool calls and call `graph.invoke({'messages': [ToolMessage(...)]})`.
+  **NOTE**: this will append the messages to the history and run the graph from the START node.
+  * manually update the state and resume the graph from the interrupt:
+    1. get the list of most recent messages from the graph state with `graph.get_state(config)`
+    2. modify the list of messages to either remove unanswered tool calls from AIMessages
+
+or add ToolMessages with tool_call_ids that match unanswered tool calls 3. call `graph.update_state(config, {'messages': ...})` with the modified list of messages 4. resume the graph, e.g. call `graph.invoke(None, config)`
+:::
+
+:::js
+* provide ToolMessages that match existing tool calls and call `graph.invoke({messages: [new ToolMessage(...)]})`.
+  **NOTE**: this will append the messages to the history and run the graph from the START node.
+  * manually update the state and resume the graph from the interrupt:
+    1. get the list of most recent messages from the graph state with `graph.getState(config)`
+    2. modify the list of messages to either remove unanswered tool calls from AIMessages
+
+or add ToolMessages with `toolCallId`s that match unanswered tool calls 3. call `graph.updateState(config, {messages: ...})` with the modified list of messages 4. resume the graph, e.g. call `graph.invoke(null, config)`
+:::

src/oss/INVALID_CONCURRENT_GRAPH_UPDATE.mdx

@@ -0,0 +1,101 @@
+---
+title: INVALID_CONCURRENT_GRAPH_UPDATE
+---
+A LangGraph [`StateGraph`](https://langchain-ai.github.io/langgraph/reference/graphs/#langgraph.graph.state.StateGraph) received concurrent updates to its state from multiple nodes to a state property that doesn't
+support it.
+
+One way this can occur is if you are using a [fanout](https://langchain-ai.github.io/langgraph/how-tos/map-reduce/)
+or other parallel execution in your graph and you have defined a graph like this:
+
+:::python
+```python hl_lines="2"
+class State(TypedDict):
+    some_key: str
+
+def node(state: State):
+    return {"some_key": "some_string_value"}
+
+def other_node(state: State):
+    return {"some_key": "some_string_value"}
+
+
+builder = StateGraph(State)
+builder.add_node(node)
+builder.add_node(other_node)
+builder.add_edge(START, "node")
+builder.add_edge(START, "other_node")
+graph = builder.compile()
+```
+:::
+
+:::js
+```typescript hl_lines="2"
+import { StateGraph, Annotation, START } from "@langchain/langgraph";
+import { z } from "zod";
+
+const State = z.object({
+  someKey: z.string(),
+});
+
+const builder = new StateGraph(State)
+  .addNode("node", (state) => {
+    return { someKey: "some_string_value" };
+  })
+  .addNode("otherNode", (state) => {
+    return { someKey: "some_string_value" };
+  })
+  .addEdge(START, "node")
+  .addEdge(START, "otherNode");
+
+const graph = builder.compile();
+```
+:::
+
+:::python
+If a node in the above graph returns `{ "some_key": "some_string_value" }`, this will overwrite the state value for `"some_key"` with `"some_string_value"`.
+However, if multiple nodes in e.g. a fanout within a single step return values for `"some_key"`, the graph will throw this error because
+there is uncertainty around how to update the internal state.
+:::
+
+:::js
+If a node in the above graph returns `{ someKey: "some_string_value" }`, this will overwrite the state value for `someKey` with `"some_string_value"`.
+However, if multiple nodes in e.g. a fanout within a single step return values for `someKey`, the graph will throw this error because
+there is uncertainty around how to update the internal state.
+:::
+
+To get around this, you can define a reducer that combines multiple values:
+
+:::python
+```python hl_lines="5-6"
+import operator
+from typing import Annotated
+
+class State(TypedDict):
+    # The operator.add reducer fn makes this append-only
+    some_key: Annotated[list, operator.add]
+```
+:::
+
+:::js
+```typescript hl_lines="4-7"
+import { withLangGraph } from "@langchain/langgraph";
+import { z } from "zod";
+
+const State = z.object({
+  someKey: withLangGraph(z.array(z.string()), {
+    reducer: {
+      fn: (existing, update) => existing.concat(update),
+    },
+    default: () => [],
+  }),
+});
+```
+:::
+
+This will allow you to define logic that handles the same key returned from multiple nodes executed in parallel.
+
+## Troubleshooting
+
+The following may help resolve this error:
+
+* If your graph executes nodes in parallel, make sure you have defined relevant state keys with a reducer.

src/oss/INVALID_GRAPH_NODE_RETURN_VALUE.mdx

@@ -0,0 +1,84 @@
+---
+title: INVALID_GRAPH_NODE_RETURN_VALUE
+---
+:::python
+A LangGraph [`StateGraph`](https://langchain-ai.github.io/langgraph/reference/graphs/#langgraph.graph.state.StateGraph)
+received a non-dict return type from a node. Here's an example:
+
+```python
+class State(TypedDict):
+    some_key: str
+
+def bad_node(state: State):
+    # Should return a dict with a value for "some_key", not a list
+    return ["whoops"]
+
+builder = StateGraph(State)
+builder.add_node(bad_node)
+...
+
+graph = builder.compile()
+```
+
+Invoking the above graph will result in an error like this:
+
+```python
+graph.invoke({ "some_key": "someval" });
+```
+
+```
+InvalidUpdateError: Expected dict, got ['whoops']
+For troubleshooting, visit: https://python.langchain.com/docs/troubleshooting/errors/INVALID_GRAPH_NODE_RETURN_VALUE
+```
+
+Nodes in your graph must return a dict containing one or more keys defined in your state.
+:::
+
+:::js
+A LangGraph [`StateGraph`](https://langchain-ai.github.io/langgraph/reference/graphs/#langgraph.graph.state.StateGraph)
+received a non-object return type from a node. Here's an example:
+
+```typescript
+import { z } from "zod";
+import { StateGraph } from "@langchain/langgraph";
+
+const State = z.object({
+  someKey: z.string(),
+});
+
+const badNode = (state: z.infer<typeof State>) => {
+  // Should return an object with a value for "someKey", not an array
+  return ["whoops"];
+};
+
+const builder = new StateGraph(State).addNode("badNode", badNode);
+// ...
+
+const graph = builder.compile();
+```
+
+Invoking the above graph will result in an error like this:
+
+```typescript
+await graph.invoke({ someKey: "someval" });
+```
+
+```
+InvalidUpdateError: Expected object, got ['whoops']
+For troubleshooting, visit: https://langchain-ai.github.io/langgraphjs/troubleshooting/errors/INVALID_GRAPH_NODE_RETURN_VALUE
+```
+
+Nodes in your graph must return an object containing one or more keys defined in your state.
+:::
+
+## Troubleshooting
+
+The following may help resolve this error:
+
+:::python
+* If you have complex logic in your node, make sure all code paths return an appropriate dict for your defined state.
+:::
+
+:::js
+* If you have complex logic in your node, make sure all code paths return an appropriate object for your defined state.
+:::

src/oss/MULTIPLE_SUBGRAPHS.mdx

@@ -0,0 +1,20 @@
+---
+title: MULTIPLE_SUBGRAPHS
+---
+You are calling subgraphs multiple times within a single LangGraph node with checkpointing enabled for each subgraph.
+
+This is currently not allowed due to internal restrictions on how checkpoint namespacing for subgraphs works.
+
+## Troubleshooting
+
+The following may help resolve this error:
+
+:::python
+* If you don't need to interrupt/resume from a subgraph, pass `checkpointer=False` when compiling it like this: `.compile(checkpointer=False)`
+:::
+
+:::js
+* If you don't need to interrupt/resume from a subgraph, pass `checkpointer: false` when compiling it like this: `.compile({ checkpointer: false })`
+:::
+
+* Don't imperatively call graphs multiple times in the same node, and instead use the [`Send`](https://langchain-ai.github.io/langgraph/concepts/low_level/#send) API.