docs[patch]: Reorder streaming guide

docs/core_docs/docs/concepts.mdx

@@ -639,6 +639,8 @@ For specifics on how to use callbacks, see the [relevant how-to guides here](/do
 
 ### Streaming
 
+<span data-heading-keywords="stream,streaming"></span>
+
 Individual LLM calls often run for much longer than traditional resource requests.
 This compounds when you build more complex chains or agents that require multiple reasoning steps.
 
@@ -648,65 +650,33 @@ around building apps with LLMs to help alleviate latency issues, and LangChain a
 
 Below, we'll discuss some concepts and considerations around streaming in LangChain.
 
-#### Tokens
-
-The unit that most model providers use to measure input and output is via a unit called a **token**.
-Tokens are the basic units that language models read and generate when processing or producing text.
-The exact definition of a token can vary depending on the specific way the model was trained -
-for instance, in English, a token could be a single word like "apple", or a part of a word like "app".
-
-When you send a model a prompt, the words and characters in the prompt are encoded into tokens using a **tokenizer**.
-The model then streams back generated output tokens, which the tokenizer decodes into human-readable text.
-The below example shows how OpenAI models tokenize `LangChain is cool!`:
-
-![](/img/tokenization.png)
-
-You can see that it gets split into 5 different tokens, and that the boundaries between tokens are not exactly the same as word boundaries.
-
-The reason language models use tokens rather than something more immediately intuitive like "characters"
-has to do with how they process and understand text. At a high-level, language models iteratively predict their next generated output based on
-the initial input and their previous generations. Training the model using tokens language models to handle linguistic
-units (like words or subwords) that carry meaning, rather than individual characters, which makes it easier for the model
-to learn and understand the structure of the language, including grammar and context.
-Furthermore, using tokens can also improve efficiency, since the model processes fewer units of text compared to character-level processing.
-
-#### Callbacks
-
-The lowest level way to stream outputs from LLMs in LangChain is via the [callbacks](/docs/concepts/#callbacks) system. You can pass a
-callback handler that handles the [`handleLLMNewToken`](https://api.js.langchain.com/interfaces/langchain_core_callbacks_base.CallbackHandlerMethods.html#handleLLMNewToken) event into LangChain components. When that component is invoked, any
-[LLM](/docs/concepts/#llms) or [chat model](/docs/concepts/#chat-models) contained in the component calls
-the callback with the generated token. Within the callback, you could pipe the tokens into some other destination, e.g. a HTTP response.
-You can also handle the [`handleLLMEnd`](https://api.js.langchain.com/interfaces/langchain_core_callbacks_base.CallbackHandlerMethods.html#handleLLMEnd) event to perform any necessary cleanup.
-
-You can see [this how-to section](/docs/how_to/#callbacks) for more specifics on using callbacks.
-
-Callbacks were the first technique for streaming introduced in LangChain. While powerful and generalizable,
-they can be unwieldy for developers. For example:
-
-- You need to explicitly initialize and manage some aggregator or other stream to collect results.
-- The execution order isn't explicitly guaranteed, and you could theoretically have a callback run after the `.invoke()` method finishes.
-- Providers would often make you pass an additional parameter to stream outputs instead of returning them all at once.
-- You would often ignore the result of the actual model call in favor of callback results.
-
 #### `.stream()`
 
-LangChain also includes the `.stream()` method as a more ergonomic streaming interface.
+Most modules in LangChain include the `.stream()` method as an ergonomic streaming interface.
 `.stream()` returns an iterator, which you can consume with a [`for await...of`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of) loop. Here's an example with a chat model:
 
 ```ts
 import { ChatAnthropic } from "@langchain/anthropic";
+import { concat } from "@langchain/core/utils/stream";
 
 const model = new ChatAnthropic({ model: "claude-3-sonnet-20240229" });
 
 const stream = await model.stream("what color is the sky?");
 
+let gathered: AIMessageChunk | undefined = undefined;
+
 for await (const chunk of stream) {
   console.log(chunk);
+  if (gathered === undefined) {
+    gathered = chunk;
+  } else {
+    gathered = concat(gathered, chunk);
+  }
 }
 ```
 
 For models (or other components) that don't support streaming natively, this iterator would just yield a single chunk, but
-you could still use the same general pattern. Using `.stream()` will also automatically call the model in streaming mode
+you could still use the same general pattern when calling them. Using `.stream()` will also automatically call the model in streaming mode
 without the need to provide additional config.
 
 The type of each outputted chunk depends on the type of component - for example, chat models yield [`AIMessageChunks`](https://api.js.langchain.com/classes/langchain_core_messages.AIMessageChunk.html).
@@ -718,13 +688,15 @@ You can check out [this guide](/docs/how_to/streaming/#using-stream) for more de
 
 #### `.streamEvents()`
 
-While the `.stream()` method is easier to use than callbacks, it only returns one type of value. This is fine for single LLM calls,
+<span data-heading-keywords="astream_events,stream_events,stream events"></span>
+
+While the `.stream()` method is intuitive, it can only return the final generated value of your chain. This is fine for single LLM calls,
 but as you build more complex chains of several LLM calls together, you may want to use the intermediate values of
 the chain alongside the final output - for example, returning sources alongside the final generation when building a chat
 over documents app.
 
-There are ways to do this using the aforementioned callbacks, or by constructing your chain in such a way that it passes intermediate
-values to the end with something like [`.assign()`](/docs/how_to/passthrough/), but LangChain also includes an
+There are ways to do this [using callbacks](/docs/concepts/#callbacks-1), or by constructing your chain in such a way that it passes intermediate
+values to the end with something like chained [`.assign()`](/docs/how_to/passthrough/) calls, but LangChain also includes an
 `.streamEvents()` method that combines the flexibility of callbacks with the ergonomics of `.stream()`. When called, it returns an iterator
 which yields [various types of events](/docs/how_to/streaming/#event-reference) that you can filter and process according
 to the needs of your project.
@@ -759,6 +731,46 @@ You can roughly think of it as an iterator over callback events (though the form
 
 See [this guide](/docs/how_to/streaming/#using-stream-events) for more detailed information on how to use `.streamEvents()`.
 
+#### Tokens
+
+The unit that most model providers use to measure input and output is via a unit called a **token**.
+Tokens are the basic units that language models read and generate when processing or producing text.
+The exact definition of a token can vary depending on the specific way the model was trained -
+for instance, in English, a token could be a single word like "apple", or a part of a word like "app".
+
+When you send a model a prompt, the words and characters in the prompt are encoded into tokens using a **tokenizer**.
+The model then streams back generated output tokens, which the tokenizer decodes into human-readable text.
+The below example shows how OpenAI models tokenize `LangChain is cool!`:
+
+![](/img/tokenization.png)
+
+You can see that it gets split into 5 different tokens, and that the boundaries between tokens are not exactly the same as word boundaries.
+
+The reason language models use tokens rather than something more immediately intuitive like "characters"
+has to do with how they process and understand text. At a high-level, language models iteratively predict their next generated output based on
+the initial input and their previous generations. Training the model using tokens language models to handle linguistic
+units (like words or subwords) that carry meaning, rather than individual characters, which makes it easier for the model
+to learn and understand the structure of the language, including grammar and context.
+Furthermore, using tokens can also improve efficiency, since the model processes fewer units of text compared to character-level processing.
+
+#### Callbacks
+
+The lowest level way to stream outputs from LLMs in LangChain is via the [callbacks](/docs/concepts/#callbacks) system. You can pass a
+callback handler that handles the [`handleLLMNewToken`](https://api.js.langchain.com/interfaces/langchain_core_callbacks_base.CallbackHandlerMethods.html#handleLLMNewToken) event into LangChain components. When that component is invoked, any
+[LLM](/docs/concepts/#llms) or [chat model](/docs/concepts/#chat-models) contained in the component calls
+the callback with the generated token. Within the callback, you could pipe the tokens into some other destination, e.g. a HTTP response.
+You can also handle the [`handleLLMEnd`](https://api.js.langchain.com/interfaces/langchain_core_callbacks_base.CallbackHandlerMethods.html#handleLLMEnd) event to perform any necessary cleanup.
+
+You can see [this how-to section](/docs/how_to/#callbacks) for more specifics on using callbacks.
+
+Callbacks were the first technique for streaming introduced in LangChain. While powerful and generalizable,
+they can be unwieldy for developers. For example:
+
+- You need to explicitly initialize and manage some aggregator or other stream to collect results.
+- The execution order isn't explicitly guaranteed, and you could theoretically have a callback run after the `.invoke()` method finishes.
+- Providers would often make you pass an additional parameter to stream outputs instead of returning them all at once.
+- You would often ignore the result of the actual model call in favor of callback results.
+
 ### Structured output
 
 LLMs are capable of generating arbitrary text. This enables the model to respond appropriately to a wide

docs/core_docs/docs/how_to/streaming.ipynb

@@ -11,6 +11,8 @@
     "This guide assumes familiarity with the following concepts:\n",
     "\n",
     "- [Chat models](/docs/concepts/#chat-models)\n",
+    "- [LangChain Expression Language](/docs/concepts/#langchain-expression-language-lcel)\n",
+    "- [Output parsers](/docs/concepts/#output-parsers)\n",
     "\n",
     ":::\n",
     "\n",
@@ -25,6 +27,10 @@
     "\n",
     "Let’s take a look at both approaches!\n",
     "\n",
+    ":::info\n",
+    "For a higher-level overview of streaming techniques in LangChain, see [this section of the conceptual guide](/docs/concepts/#streaming).\n",
+    ":::\n",
+    "\n",
     "# Using Stream\n",
     "\n",
     "All `Runnable` objects implement a method called stream.\n",