fix links

Author: lnhsingh

src/oss/get-started/1-build-basic-chatbot.mdx renamed to src/oss/1-build-basic-chatbot.mdx

@@ -4,7 +4,7 @@ title: Add tools
 To handle queries that your chatbot can't answer "from memory", integrate a web search tool. The chatbot can use this tool to find relevant information and provide better responses.
 
 <Note>
-  This tutorial builds on [Build a basic chatbot](./1-build-basic-chatbot).
+  This tutorial builds on [Build a basic chatbot](/oss/1-build-basic-chatbot).
 </Note>
 
 ## Prerequisites
@@ -152,11 +152,11 @@ The results are page summaries our chat bot can use to answer questions:
 ## 4. Define the graph
 
 :::python
-For the `StateGraph` you created in the [first tutorial](./1-build-basic-chatbot), add `bind_tools` on the LLM. This lets the LLM know the correct JSON format to use if it wants to use the search engine.
+For the `StateGraph` you created in the [first tutorial](/oss/1-build-basic-chatbot), add `bind_tools` on the LLM. This lets the LLM know the correct JSON format to use if it wants to use the search engine.
 :::
 
 :::js
-For the `StateGraph` you created in the [first tutorial](./1-build-basic-chatbot), add `bindTools` on the LLM. This lets the LLM know the correct JSON format to use if it wants to use the search engine.
+For the `StateGraph` you created in the [first tutorial](/oss/1-build-basic-chatbot), add `bindTools` on the LLM. This lets the LLM know the correct JSON format to use if it wants to use the search engine.
 :::
 
 Let's first select our LLM:
@@ -698,4 +698,4 @@ To inspect all the steps your agent just took, check out this [LangSmith trace](
 
 ## Next steps
 
-The chatbot cannot remember past interactions on its own, which limits its ability to have coherent, multi-turn conversations. In the next part, you will [add **memory**](./3-add-memory) to address this.
+The chatbot cannot remember past interactions on its own, which limits its ability to have coherent, multi-turn conversations. In the next part, you will [add **memory**](/oss/3-add-memory) to address this.

src/oss/get-started/2-add-tools.mdx renamed to src/oss/2-add-tools.mdx

@@ -1,14 +1,14 @@
 ---
 title: Add memory
 ---
-The chatbot can now [use tools](./2-add-tools) to answer user questions, but it does not remember the context of previous interactions. This limits its ability to have coherent, multi-turn conversations.
+The chatbot can now [use tools](/oss/2-add-tools) to answer user questions, but it does not remember the context of previous interactions. This limits its ability to have coherent, multi-turn conversations.
 
 LangGraph solves this problem through **persistent checkpointing**. If you provide a `checkpointer` when compiling the graph and a `thread_id` when calling your graph, LangGraph automatically saves the state after each step. When you invoke the graph again using the same `thread_id`, the graph loads its saved state, allowing the chatbot to pick up where it left off.
 
 We will see later that **checkpointing** is _much_ more powerful than simple chat memory - it lets you save and resume complex state at any time for error recovery, human-in-the-loop workflows, time travel interactions, and more. But first, let's add checkpointing to enable multi-turn conversations.
 
 <Note>
-  This tutorial builds on [Add tools](./2-add-tools).
+  This tutorial builds on [Add tools](/oss/2-add-tools).
 </Note>
 
 ## 1. Create a `MemorySaver` checkpointer
@@ -414,4 +414,4 @@ const graph = new StateGraph(State)
 
 ## Next steps
 
-In the next tutorial, you will [add human-in-the-loop to the chatbot](./4-human-in-the-loop) to handle situations where it may need guidance or verification before proceeding.
+In the next tutorial, you will [add human-in-the-loop to the chatbot](/oss/4-human-in-the-loop) to handle situations where it may need guidance or verification before proceeding.

src/oss/get-started/3-add-memory.mdx renamed to src/oss/3-add-memory.mdx

@@ -3,15 +3,15 @@ title: Add human-in-the-loop controls
 ---
 Agents can be unreliable and may need human input to successfully accomplish tasks. Similarly, for some actions, you may want to require human approval before running to ensure that everything is running as intended.
 
-LangGraph's [persistence](../../concepts/persistence) layer supports **human-in-the-loop** workflows, allowing execution to pause and resume based on user feedback. The primary interface to this functionality is the [`interrupt`](../../how-tos/human_in_the_loop/add-human-in-the-loop) function. Calling `interrupt` inside a node will pause execution. Execution can be resumed, together with new input from a human, by passing in a [Command](../../concepts/low_level#command).
+LangGraph's [persistence](.././persistence) layer supports **human-in-the-loop** workflows, allowing execution to pause and resume based on user feedback. The primary interface to this functionality is the [`interrupt`](.././human_in_the_loop/add-human-in-the-loop) function. Calling `interrupt` inside a node will pause execution. Execution can be resumed, together with new input from a human, by passing in a [Command](.././low_level#command).
 
 :::python
-`interrupt` is ergonomically similar to Python's built-in `input()`, [with some caveats](../../how-tos/human_in_the_loop/add-human-in-the-loop).
+`interrupt` is ergonomically similar to Python's built-in `input()`, [with some caveats](.././human_in_the_loop/add-human-in-the-loop).
 :::
 
 :::js
-`interrupt` is ergonomically similar to Node.js's built-in `readline.question()` function, [with some caveats](../../how-tos/human_in_the_loop/add-human-in-the-loop).
-`interrupt` is ergonomically similar to Node.js's built-in `readline.question()` function, [with some caveats](../../how-tos/human_in_the_loop/add-human-in-the-loop).
+`interrupt` is ergonomically similar to Node.js's built-in `readline.question()` function, [with some caveats](.././human_in_the_loop/add-human-in-the-loop).
+`interrupt` is ergonomically similar to Node.js's built-in `readline.question()` function, [with some caveats](.././human_in_the_loop/add-human-in-the-loop).
 :::
 
 <Note>
@@ -150,7 +150,7 @@ async function chatbot(state: z.infer<typeof MessagesZodState>) {
 :::
 
 <Tip>
-  For more information and examples of human-in-the-loop workflows, see [Human-in-the-loop](../../concepts/human_in_the_loop).
+  For more information and examples of human-in-the-loop workflows, see [Human-in-the-loop](.././human_in_the_loop).
 </Tip>
 
 ## 2. Compile the graph
@@ -353,7 +353,7 @@ snapshot.next;
       return human_response["data"]
   ```
   
-  Similar to Python's built-in `input()` function, calling `interrupt` inside the tool will pause execution. Progress is persisted based on the [checkpointer](../../concepts/persistence#checkpointer-libraries); so if it is persisting with Postgres, it can resume at any time as long as the database is alive. In this example, it is persisting with the in-memory checkpointer and can resume any time if the Python kernel is running.
+  Similar to Python's built-in `input()` function, calling `interrupt` inside the tool will pause execution. Progress is persisted based on the [checkpointer](.././persistence#checkpointer-libraries); so if it is persisting with Postgres, it can resume at any time as long as the database is alive. In this example, it is persisting with the in-memory checkpointer and can resume any time if the Python kernel is running.
   :::
   
   :::js
@@ -394,12 +394,12 @@ snapshot.next;
   
   ```
 
-  Calling `interrupt` inside the tool will pause execution. Progress is persisted based on the [checkpointer](../../concepts/persistence#checkpointer-libraries); so if it is persisting with Postgres, it can resume at any time as long as the database is alive. In this example, it is persisting with the in-memory checkpointer and can resume any time if the JavaScript runtime is running.
+  Calling `interrupt` inside the tool will pause execution. Progress is persisted based on the [checkpointer](.././persistence#checkpointer-libraries); so if it is persisting with Postgres, it can resume at any time as long as the database is alive. In this example, it is persisting with the in-memory checkpointer and can resume any time if the JavaScript runtime is running.
   :::
 
   ## 5. Resume execution
 
-  To resume execution, pass a [`Command`](../../concepts/low_level#command) object containing data expected by the tool. The format of this data can be customized based on needs.
+  To resume execution, pass a [`Command`](.././low_level#command) object containing data expected by the tool. The format of this data can be customized based on needs.
 
   :::python
 

src/oss/get-started/4-human-in-the-loop.mdx renamed to src/oss/4-human-in-the-loop.mdx

@@ -4,7 +4,7 @@ title: Customize state
 In this tutorial, you will add additional fields to the state to define complex behavior without relying on the message list. The chatbot will use its search tool to find specific information and forward them to a human for review.
 
 <Note>
-  This tutorial builds on [Add human-in-the-loop controls](./4-human-in-the-loop).
+  This tutorial builds on [Add human-in-the-loop controls](/oss/4-human-in-the-loop).
 </Note>
 
 ## 1. Add keys to the state
@@ -49,7 +49,7 @@ Adding this information to the state makes it easily accessible by other graph n
 ## 2. Update the state inside the tool
 
 :::python
-Now, populate the state keys inside of the `human_assistance` tool. This allows a human to review the information before it is stored in the state. Use [`Command`](../../concepts/low_level#using-inside-tools) to issue a state update from inside the tool.
+Now, populate the state keys inside of the `human_assistance` tool. This allows a human to review the information before it is stored in the state. Use [`Command`](.././low_level#using-inside-tools) to issue a state update from inside the tool.
 
 ```python
 from langchain_core.messages import ToolMessage
@@ -97,7 +97,7 @@ def human_assistance(
 :::
 
 :::js
-Now, populate the state keys inside of the `humanAssistance` tool. This allows a human to review the information before it is stored in the state. Use [`Command`](../../concepts/low_level#using-inside-tools) to issue a state update from inside the tool.
+Now, populate the state keys inside of the `humanAssistance` tool. This allows a human to review the information before it is stored in the state. Use [`Command`](.././low_level#using-inside-tools) to issue a state update from inside the tool.
 
 ```typescript
 import { tool } from "@langchain/core/tools";
@@ -454,7 +454,7 @@ const updatedRelevantState = Object.fromEntries(
 ```
 :::
 
-Manual state updates will [generate a trace](https://smith.langchain.com/public/7ebb7827-378d-49fe-9f6c-5df0e90086c8/r) in LangSmith. If desired, they can also be used to [control human-in-the-loop workflows](../../how-tos/human_in_the_loop/add-human-in-the-loop). Use of the `interrupt` function is generally recommended instead, as it allows data to be transmitted in a human-in-the-loop interaction independently of state updates.
+Manual state updates will [generate a trace](https://smith.langchain.com/public/7ebb7827-378d-49fe-9f6c-5df0e90086c8/r) in LangSmith. If desired, they can also be used to [control human-in-the-loop workflows](.././human_in_the_loop/add-human-in-the-loop). Use of the `interrupt` function is generally recommended instead, as it allows data to be transmitted in a human-in-the-loop interaction independently of state updates.
 
 **Congratulations!** You've added custom keys to the state to facilitate a more complex workflow, and learned how to generate state updates from inside tools.
 
@@ -651,4 +651,4 @@ const graph = new StateGraph(State)
 
 ## Next steps
 
-There's one more concept to review before finishing the LangGraph basics tutorials: connecting `checkpointing` and `state updates` to [time travel](./6-time-travel).
+There's one more concept to review before finishing the LangGraph basics tutorials: connecting `checkpointing` and `state updates` to [time travel](/oss/6-time-travel).

src/oss/get-started/5-customize-state.mdx renamed to src/oss/5-customize-state.mdx

@@ -1,14 +1,14 @@
 ---
 title: Time travel
 ---
-In a typical chatbot workflow, the user interacts with the bot one or more times to accomplish a task. [Memory](./3-add-memory) and a [human-in-the-loop](./4-human-in-the-loop) enable checkpoints in the graph state and control future responses.
+In a typical chatbot workflow, the user interacts with the bot one or more times to accomplish a task. [Memory](/oss/3-add-memory) and a [human-in-the-loop](/oss/4-human-in-the-loop) enable checkpoints in the graph state and control future responses.
 
 What if you want a user to be able to start from a previous response and explore a different outcome? Or what if you want users to be able to rewind your chatbot's work to fix mistakes or try a different strategy, something that is common in applications like autonomous software engineers?
 
 You can create these types of experiences using LangGraph's built-in **time travel** functionality.
 
 <Note>
-  This tutorial builds on [Customize state](./5-customize-state).
+  This tutorial builds on [Customize state](/oss/5-customize-state).
 </Note>
 
 ## 1. Rewind your graph
@@ -602,6 +602,6 @@ The graph resumed execution from the `tools` node. You can tell this is the case
 
 Take your LangGraph journey further by exploring deployment and advanced features:
 
-* **[LangGraph Server quickstart](../../tutorials/langgraph-platform/local-server)**: Launch a LangGraph server locally and interact with it using the REST API and LangGraph Studio Web UI.
+* **[LangGraph Server quickstart](../../langgraph-platform/local-server)**: Launch a LangGraph server locally and interact with it using the REST API and LangGraph Studio Web UI.
 * **[LangGraph Platform quickstart](../../cloud/quick_start)**: Deploy your LangGraph app using LangGraph Platform.
-* **[LangGraph Platform concepts](../../concepts/langgraph_platform)**: Understand the foundational concepts of the LangGraph Platform.
+* **[LangGraph Platform concepts](../../langgraph-platform/concepts)**: Understand the foundational concepts of the LangGraph Platform.

src/oss/get-started/6-time-travel.mdx renamed to src/oss/6-time-travel.mdx

@@ -4,7 +4,7 @@ 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/)
+One way this can occur is if you are using a [fanout](/oss/graph-api#map-reduce-and-the-send-api)
 or other parallel execution in your graph and you have defined a graph like this:
 
 :::python

src/oss/INVALID_CONCURRENT_GRAPH_UPDATE.mdx

@@ -17,4 +17,4 @@ The following may help resolve this error:
 * 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.
+* Don't imperatively call graphs multiple times in the same node, and instead use the [`Send`](/oss/low-level#send) API.