Harrison/changes (#851)

Author: hwchase17

src/docs.json

@@ -176,15 +176,15 @@
                   {
                     "group": "Advanced usage",
                     "pages": [
-                      "oss/python/langchain/long-term-memory",
-                      "oss/python/langchain/context-engineering",
+                      "oss/python/langchain/middleware",
                       "oss/python/langchain/structured-output",
+                      "oss/python/langchain/runtime",
+                      "oss/python/langchain/context-engineering",
                       "oss/python/langchain/mcp",
                       "oss/python/langchain/human-in-the-loop",
                       "oss/python/langchain/multi-agent",
                       "oss/python/langchain/retrieval",
-                      "oss/python/langchain/runtime",
-                      "oss/python/langchain/middleware"
+                      "oss/python/langchain/long-term-memory"
                     ]
                   },
                   {
@@ -1197,15 +1197,15 @@
                   {
                     "group": "Advanced usage",
                     "pages": [
-                      "oss/javascript/langchain/long-term-memory",
-                      "oss/javascript/langchain/context-engineering",
+                      "oss/javascript/langchain/middleware",
                       "oss/javascript/langchain/structured-output",
+                      "oss/javascript/langchain/runtime",
+                      "oss/javascript/langchain/context-engineering",
                       "oss/javascript/langchain/mcp",
                       "oss/javascript/langchain/human-in-the-loop",
                       "oss/javascript/langchain/multi-agent",
                       "oss/javascript/langchain/retrieval",
-                      "oss/javascript/langchain/runtime",
-                      "oss/javascript/langchain/middleware"
+                      "oss/javascript/langchain/long-term-memory"
                     ]
                   },
                   {

src/oss/contributing/comarketing.mdx

@@ -2,7 +2,7 @@
 title: Co-marketing
 ---
 
-With over 20 million monthly downloads, LangChain has a large audience of developers building LLM applications. Beyond just listing integrations, we aim to highlight high-quality, educational examples that inspire developers and advance the ecosystem.
+With over 60 million monthly downloads, LangChain has a large audience of developers building LLM applications. Beyond just listing integrations, we aim to highlight high-quality, educational examples that inspire developers and advance the ecosystem.
 
 <Note>
     While we occasionally share integrations, we prioritize content that provides

src/oss/langchain/agents.mdx

@@ -9,15 +9,14 @@ import AlphaCallout from '/snippets/alpha-lc-callout.mdx';
 Agents combine language models with tools to create systems that can reason about tasks, decide which tools to use, and iteratively work towards solutions.
 
 :::python
-`create_agent()` provides a production-ready ReAct (Reasoning + Acting) agent implementation based on the paper [ReAct: Synergizing Reasoning and Acting in Language Models](https://arxiv.org/abs/2210.03629).
+`create_agent()` provides a production-ready agent implementation.
 :::
 :::js
-`createAgent()` provides a production-ready ReAct (Reasoning + Acting) agent implementation based on the paper [ReAct: Synergizing Reasoning and Acting in Language Models](https://arxiv.org/abs/2210.03629).
+`createAgent()` provides a production-ready agent implementation.
 :::
 
-ReAct frames an agent's behavior as an interleaving of `thought` -> `action` -> `observation` steps, where the model writes out its reasoning, picks a tool, sees the tool's result, and then repeats. ReAct reduces hallucinations and makes the decision process auditable: the agent can form hypotheses (`thought`), test them with tools (`action`), and update its plan based on feedback (`observation`).
-
-A ReAct loop runs until a stop condition - i.e., when the model emits a final answer or an iteration limit is reached.
+[An LLM Agent runs tools in a loop to achieve a goal](https://simonwillison.net/2025/Sep/18/agents/).
+An agent runs until a stop condition is met - i.e., when the model emits a final output or an iteration limit is reached.
 
 ```mermaid
 %%{
@@ -31,10 +30,10 @@ A ReAct loop runs until a stop condition - i.e., when the model emits a final an
 }%%
 graph TD
   %% Outside the agent
-  QUERY([query])
-  LLM{thought}
+  QUERY([input])
+  LLM{model}
   TOOL(tools)
-  ANSWER([answer])
+  ANSWER([output])
 
   %% Main flows (no inline labels)
   QUERY --> LLM
@@ -51,10 +50,10 @@ graph TD
 <Info>
 
 :::python
-`create_agent()` builds a **graph**-based agent runtime using [LangGraph](/oss/langgraph/overview). A graph consists of nodes (steps) and edges (connections) that define how your agent processes information. The agent moves through this graph, executing nodes like the model node (which calls the model), the tools node (which executes tools), or pre/post model hook nodes.
+`create_agent()` builds a **graph**-based agent runtime using [LangGraph](/oss/langgraph/overview). A graph consists of nodes (steps) and edges (connections) that define how your agent processes information. The agent moves through this graph, executing nodes like the model node (which calls the model), the tools node (which executes tools), or middleware.
 :::
 :::js
-`createAgent()` builds a **graph**-based agent runtime using [LangGraph](/oss/langgraph/overview). A graph consists of nodes (steps) and edges (connections) that define how your agent processes information. The agent moves through this graph, executing nodes like the model node (which calls the model), the tools node (which executes tools), or pre/post model hook nodes.
+`createAgent()` builds a **graph**-based agent runtime using [LangGraph](/oss/langgraph/overview). A graph consists of nodes (steps) and edges (connections) that define how your agent processes information. The agent moves through this graph, executing nodes like the model node (which calls the model), the tools node (which executes tools), or middleware.
 :::
 
 Learn more about the [graph API](/oss/langgraph/graph-api).

src/oss/langchain/philosophy.mdx

@@ -24,7 +24,7 @@ With LangChain, we have two core focuses:
         Standardizing these model inputs and outputs is a core focus, making it easy for developer to easily change to the most recent state-of-the-art model, avoiding lock-in.
     </Step>
     <Step title="We want to make it easy to use models to orchestrate more complex flows that interact with other data and computation.">
-        Models should be used for more than just *calling* - they should also be used to orchestrate more complex flows that interact with other data. LangChain makes it easy to define [tools](/oss/langchain/tools) that LLMs can use dynamically, as well as help with parsing of and access to unstructured data.
+        Models should be used for more than just *text generation* - they should also be used to orchestrate more complex flows that interact with other data. LangChain makes it easy to define [tools](/oss/langchain/tools) that LLMs can use dynamically, as well as help with parsing of and access to unstructured data.
     </Step>
 </Steps>
 

src/oss/langchain/structured-output.mdx

@@ -10,7 +10,7 @@ import AlphaCallout from '/snippets/alpha-lc-callout.mdx';
 
 Structured output allows agents to return data in a specific, predictable format. Instead of parsing natural language responses, you get structured data in the form of JSON objects, Pydantic models, or dataclasses that your application can directly use.
 
-LangChain's prebuilt ReAct agent `create_agent()` handles structured output automatically. The user sets their desired structured output schema, and when the model generates the structured data, it's captured, validated, and returned in the `'structured_response'` key of the agent's state.
+LangChain's `create_agent()` handles structured output automatically. The user sets their desired structured output schema, and when the model generates the structured data, it's captured, validated, and returned in the `'structured_response'` key of the agent's state.
 
 ```python
 def create_agent(
@@ -22,20 +22,19 @@ def create_agent(
     ]
 ```
 
-<ParamField path="response_format">
-    Controls how the agent returns structured data:
+## Response Format
+Controls how the agent returns structured data:
 
-    - **`ToolStrategy[StructuredResponseT]`**: `Uses tool calling for structured output
-    - **`ProviderStrategy[StructuredResponseT]`**: Uses provider-native structured output
-    - **`type[StructuredResponseT]`**: Schema type - automatically selects best strategy based on model capabilities
-    - **`None`**: No structured output
+- **`ToolStrategy[StructuredResponseT]`**: Uses tool calling for structured output
+- **`ProviderStrategy[StructuredResponseT]`**: Uses provider-native structured output
+- **`type[StructuredResponseT]`**: Schema type - automatically selects best strategy based on model capabilities
+- **`None`**: No structured output
 
-    When a schema type is provided directly, LangChain automatically chooses:
-    - `ProviderStrategy` for models supporting native structured output (OpenAI, Grok)
-    - `ToolStrategy` for all other models
+When a schema type is provided directly, LangChain automatically chooses:
+- `ProviderStrategy` for models supporting native structured output (OpenAI, Grok)
+- `ToolStrategy` for all other models
 
-    The structured response is returned in the `structured_response` key of the agent's final state.
-</ParamField>
+The structured response is returned in the `structured_response` key of the agent's final state.
 :::
 :::js
 Structured output allows agents to return data in a specific, predictable format. Instead of parsing natural language responses, you get typed structured data.
@@ -54,7 +53,7 @@ const agent = createAgent({
 })
 ```
 
-<ParamField path="responseFormat">
+## Response Format
     Controls how the agent returns structured data. You can provide either a Zod object or JSON schema. By default, the agent uses a tool calling strategy, in which the output is created by an additional tool call. Certain models support native structured output, in which case the agent will use that strategy instead.
 
     You can control the behavior by wrapping `ResponseFormat` in a `toolStrategy` or `providerStrategy` function call:
@@ -71,7 +70,6 @@ const agent = createAgent({
     ```
 
     The structured response is returned in the `structuredResponse` key of the agent's final state.
-</ParamField>
 :::
 
 ## Provider strategy

src/oss/langchain/supervisor.mdx

@@ -68,7 +68,7 @@ We will need to select a chat model from LangChain's suite of integrations:
 
 <ChatModelTabsPy />
 
-## 1. Define low-level API tools
+## 1. Define tools
 
 Start by defining the tools that require structured inputs. In real applications, these would call actual APIs (Google Calendar, SendGrid, etc.). For this tutorial, you'll use stubs to demonstrate the pattern.