core: release 0.3.6 (#26863)

- **Description:** This pull request addresses the validation error in
`SettingsConfigDict` due to extra fields in the `.env` file. The issue
is prevalent across multiple Langchain modules. This fix ensures that
extra fields in the `.env` file are ignored, preventing validation
errors.
  **Changes include:**
    - Applied fixes to modules using `SettingsConfigDict`.

- **Issue:** NA, similar
https://github.com/langchain-ai/langchain/issues/26850
- **Dependencies:** NA

.github/workflows/_integration_test.yml

@@ -58,6 +58,7 @@ jobs:
           AZURE_OPENAI_API_BASE: ${{ secrets.AZURE_OPENAI_API_BASE }}
           AZURE_OPENAI_API_KEY: ${{ secrets.AZURE_OPENAI_API_KEY }}
           AZURE_OPENAI_CHAT_DEPLOYMENT_NAME: ${{ secrets.AZURE_OPENAI_CHAT_DEPLOYMENT_NAME }}
+          AZURE_OPENAI_LEGACY_CHAT_DEPLOYMENT_NAME: ${{ secrets.AZURE_OPENAI_LEGACY_CHAT_DEPLOYMENT_NAME }}
           AZURE_OPENAI_LLM_DEPLOYMENT_NAME: ${{ secrets.AZURE_OPENAI_LLM_DEPLOYMENT_NAME }}
           AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT_NAME: ${{ secrets.AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT_NAME }}
           MISTRAL_API_KEY: ${{ secrets.MISTRAL_API_KEY }}

.github/workflows/scheduled_test.yml

@@ -86,6 +86,7 @@ jobs:
           AZURE_OPENAI_API_BASE: ${{ secrets.AZURE_OPENAI_API_BASE }}
           AZURE_OPENAI_API_KEY: ${{ secrets.AZURE_OPENAI_API_KEY }}
           AZURE_OPENAI_CHAT_DEPLOYMENT_NAME: ${{ secrets.AZURE_OPENAI_CHAT_DEPLOYMENT_NAME }}
+          AZURE_OPENAI_LEGACY_CHAT_DEPLOYMENT_NAME: ${{ secrets.AZURE_OPENAI_LEGACY_CHAT_DEPLOYMENT_NAME }}
           AZURE_OPENAI_LLM_DEPLOYMENT_NAME: ${{ secrets.AZURE_OPENAI_LLM_DEPLOYMENT_NAME }}
           AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT_NAME: ${{ secrets.AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT_NAME }}
           FIREWORKS_API_KEY: ${{ secrets.FIREWORKS_API_KEY }}

README.md

@@ -38,7 +38,7 @@ conda install langchain -c conda-forge
 
 For these applications, LangChain simplifies the entire application lifecycle:
 
-- **Open-source libraries**: Build your applications using LangChain's open-source [building blocks](https://python.langchain.com/v0.2/docs/concepts#langchain-expression-language-lcel), [components](https://python.langchain.com/v0.2/docs/concepts), and [third-party integrations](https://python.langchain.com/v0.2/docs/integrations/platforms/).
+- **Open-source libraries**: Build your applications using LangChain's open-source [building blocks](https://python.langchain.com/docs/concepts/#langchain-expression-language-lcel), [components](https://python.langchain.com/docs/concepts/), and [third-party integrations](https://python.langchain.com/docs/integrations/platforms/).
   Use [LangGraph](https://langchain-ai.github.io/langgraph/) to build stateful agents with first-class streaming and human-in-the-loop support.
 - **Productionization**: Inspect, monitor, and evaluate your apps with [LangSmith](https://docs.smith.langchain.com/) so that you can constantly optimize and deploy with confidence.
 - **Deployment**: Turn your LangGraph applications into production-ready APIs and Assistants with [LangGraph Cloud](https://langchain-ai.github.io/langgraph/cloud/).
@@ -65,20 +65,20 @@ For these applications, LangChain simplifies the entire application lifecycle:
 
 **❓ Question answering with RAG**
 
-- [Documentation](https://python.langchain.com/v0.2/docs/tutorials/rag/)
+- [Documentation](https://python.langchain.com/docs/tutorials/rag/)
 - End-to-end Example: [Chat LangChain](https://chat.langchain.com) and [repo](https://github.com/langchain-ai/chat-langchain)
 
 **🧱 Extracting structured output**
 
-- [Documentation](https://python.langchain.com/v0.2/docs/tutorials/extraction/)
+- [Documentation](https://python.langchain.com/docs/tutorials/extraction/)
 - End-to-end Example: [SQL Llama2 Template](https://github.com/langchain-ai/langchain-extract/)
 
 **🤖 Chatbots**
 
-- [Documentation](https://python.langchain.com/v0.2/docs/tutorials/chatbot/)
+- [Documentation](https://python.langchain.com/docs/tutorials/chatbot/)
 - End-to-end Example: [Web LangChain (web researcher chatbot)](https://weblangchain.vercel.app) and [repo](https://github.com/langchain-ai/weblangchain)
 
-And much more! Head to the [Tutorials](https://python.langchain.com/v0.2/docs/tutorials/) section of the docs for more.
+And much more! Head to the [Tutorials](https://python.langchain.com/docs/tutorials/) section of the docs for more.
 
 ## 🚀 How does LangChain help?
 
@@ -93,10 +93,10 @@ Off-the-shelf chains make it easy to get started. Components make it easy to cus
 
 LCEL is a key part of LangChain, allowing you to build and organize chains of processes in a straightforward, declarative manner. It was designed to support taking prototypes directly into production without needing to alter any code. This means you can use LCEL to set up everything from basic "prompt + LLM" setups to intricate, multi-step workflows.
 
-- **[Overview](https://python.langchain.com/v0.2/docs/concepts/#langchain-expression-language-lcel)**: LCEL and its benefits
-- **[Interface](https://python.langchain.com/v0.2/docs/concepts/#runnable-interface)**: The standard Runnable interface for LCEL objects
-- **[Primitives](https://python.langchain.com/v0.2/docs/how_to/#langchain-expression-language-lcel)**: More on the primitives LCEL includes
-- **[Cheatsheet](https://python.langchain.com/v0.2/docs/how_to/lcel_cheatsheet/)**: Quick overview of the most common usage patterns
+- **[Overview](https://python.langchain.com/docs/concepts/#langchain-expression-language-lcel)**: LCEL and its benefits
+- **[Interface](https://python.langchain.com/docs/concepts/#runnable-interface)**: The standard Runnable interface for LCEL objects
+- **[Primitives](https://python.langchain.com/docs/how_to/#langchain-expression-language-lcel)**: More on the primitives LCEL includes
+- **[Cheatsheet](https://python.langchain.com/docs/how_to/lcel_cheatsheet/)**: Quick overview of the most common usage patterns
 
 ## Components
 
@@ -104,24 +104,24 @@ Components fall into the following **modules**:
 
 **📃 Model I/O**
 
-This includes [prompt management](https://python.langchain.com/v0.2/docs/concepts/#prompt-templates), [prompt optimization](https://python.langchain.com/v0.2/docs/concepts/#example-selectors), a generic interface for [chat models](https://python.langchain.com/v0.2/docs/concepts/#chat-models) and [LLMs](https://python.langchain.com/v0.2/docs/concepts/#llms), and common utilities for working with [model outputs](https://python.langchain.com/v0.2/docs/concepts/#output-parsers).
+This includes [prompt management](https://python.langchain.com/docs/concepts/#prompt-templates), [prompt optimization](https://python.langchain.com/docs/concepts/#example-selectors), a generic interface for [chat models](https://python.langchain.com/docs/concepts/#chat-models) and [LLMs](https://python.langchain.com/docs/concepts/#llms), and common utilities for working with [model outputs](https://python.langchain.com/docs/concepts/#output-parsers).
 
 **📚 Retrieval**
 
-Retrieval Augmented Generation involves [loading data](https://python.langchain.com/v0.2/docs/concepts/#document-loaders) from a variety of sources, [preparing it](https://python.langchain.com/v0.2/docs/concepts/#text-splitters), then [searching over (a.k.a. retrieving from)](https://python.langchain.com/v0.2/docs/concepts/#retrievers) it for use in the generation step.
+Retrieval Augmented Generation involves [loading data](https://python.langchain.com/docs/concepts/#document-loaders) from a variety of sources, [preparing it](https://python.langchain.com/docs/concepts/#text-splitters), then [searching over (a.k.a. retrieving from)](https://python.langchain.com/docs/concepts/#retrievers) it for use in the generation step.
 
 **🤖 Agents**
 
-Agents allow an LLM autonomy over how a task is accomplished. Agents make decisions about which Actions to take, then take that Action, observe the result, and repeat until the task is complete. LangChain provides a [standard interface for agents](https://python.langchain.com/v0.2/docs/concepts/#agents), along with [LangGraph](https://github.com/langchain-ai/langgraph) for building custom agents.
+Agents allow an LLM autonomy over how a task is accomplished. Agents make decisions about which Actions to take, then take that Action, observe the result, and repeat until the task is complete. LangChain provides a [standard interface for agents](https://python.langchain.com/docs/concepts/#agents), along with [LangGraph](https://github.com/langchain-ai/langgraph) for building custom agents.
 
 ## 📖 Documentation
 
 Please see [here](https://python.langchain.com) for full documentation, which includes:
 
-- [Introduction](https://python.langchain.com/v0.2/docs/introduction/): Overview of the framework and the structure of the docs.
+- [Introduction](https://python.langchain.com/docs/introduction/): Overview of the framework and the structure of the docs.
 - [Tutorials](https://python.langchain.com/docs/use_cases/): If you're looking to build something specific or are more of a hands-on learner, check out our tutorials. This is the best place to get started.
-- [How-to guides](https://python.langchain.com/v0.2/docs/how_to/): Answers to “How do I….?” type questions. These guides are goal-oriented and concrete; they're meant to help you complete a specific task.
-- [Conceptual guide](https://python.langchain.com/v0.2/docs/concepts/): Conceptual explanations of the key parts of the framework.
+- [How-to guides](https://python.langchain.com/docs/how_to/): Answers to “How do I….?” type questions. These guides are goal-oriented and concrete; they're meant to help you complete a specific task.
+- [Conceptual guide](https://python.langchain.com/docs/concepts/): Conceptual explanations of the key parts of the framework.
 - [API Reference](https://api.python.langchain.com): Thorough documentation of every class and method.
 
 ## 🌐 Ecosystem
@@ -134,7 +134,7 @@ Please see [here](https://python.langchain.com) for full documentation, which in
 
 As an open-source project in a rapidly developing field, we are extremely open to contributions, whether it be in the form of a new feature, improved infrastructure, or better documentation.
 
-For detailed information on how to contribute, see [here](https://python.langchain.com/v0.2/docs/contributing/).
+For detailed information on how to contribute, see [here](https://python.langchain.com/docs/contributing/).
 
 ## 🌟 Contributors
 

docs/Makefile

@@ -46,7 +46,7 @@ generate-files:
 
 	$(PYTHON) scripts/partner_pkg_table.py $(INTERMEDIATE_DIR)
 
-	wget -q https://raw.githubusercontent.com/langchain-ai/langserve/main/README.md -O $(INTERMEDIATE_DIR)/langserve.md
+	curl https://raw.githubusercontent.com/langchain-ai/langserve/main/README.md | sed 's/<=/\&lt;=/g' > $(INTERMEDIATE_DIR)/langserve.md
 	$(PYTHON) scripts/resolve_local_links.py $(INTERMEDIATE_DIR)/langserve.md https://github.com/langchain-ai/langserve/tree/main/
 
 copy-infra:
@@ -65,7 +65,7 @@ render:
 	$(PYTHON) scripts/notebook_convert.py $(INTERMEDIATE_DIR) $(OUTPUT_NEW_DOCS_DIR)
 
 md-sync:
-	rsync -avm --include="*/" --include="*.mdx" --include="*.md" --include="*.png" --include="*/_category_.yml" --exclude="*" $(INTERMEDIATE_DIR)/ $(OUTPUT_NEW_DOCS_DIR)
+	rsync -avmq --include="*/" --include="*.mdx" --include="*.md" --include="*.png" --include="*/_category_.yml" --exclude="*" $(INTERMEDIATE_DIR)/ $(OUTPUT_NEW_DOCS_DIR)
 
 append-related:
 	$(PYTHON) scripts/append_related_links.py $(OUTPUT_NEW_DOCS_DIR)
@@ -85,7 +85,7 @@ vercel-build: install-vercel-deps build generate-references
 	git clone --depth=1 https://github.com/baskaryan/langchain-api-docs-build.git
 	mv langchain-api-docs-build/api_reference_build/html/* static/api_reference/
 	rm -rf langchain-api-docs-build
-	NODE_OPTIONS="--max-old-space-size=6000" yarn run docusaurus build
+	NODE_OPTIONS="--max-old-space-size=5000" yarn run docusaurus build
 
 start:
 	cd $(OUTPUT_NEW_DIR) && yarn && yarn start --port=$(PORT)

docs/docs/additional_resources/arxiv_references.mdx

@@ -451,8 +451,7 @@ steps of the thought-process and explore other directions from there. To verify
 the effectiveness of the proposed technique, we implemented a ToT-based solver
 for the Sudoku Puzzle. Experimental results show that the ToT framework can
 significantly increase the success rate of Sudoku puzzle solving. Our
-implementation of the ToT-based Sudoku solver is available on GitHub:
-\url{https://github.com/jieyilong/tree-of-thought-puzzle-solver}.
+implementation of the ToT-based Sudoku solver is available on [GitHub](https://github.com/jieyilong/tree-of-thought-puzzle-solver).
                 
 ## Plan-and-Solve Prompting: Improving Zero-Shot Chain-of-Thought Reasoning by Large Language Models
 

docs/docs/concepts.mdx

@@ -116,14 +116,14 @@ These also have corresponding async methods that should be used with [asyncio](h
 
 The **input type** and **output type** varies by component:
 
-| Component | Input Type | Output Type |
-| --- | --- | --- |
-| Prompt | Dictionary | PromptValue |
-| ChatModel | Single string, list of chat messages or a PromptValue | ChatMessage |
-| LLM | Single string, list of chat messages or a PromptValue | String |
-| OutputParser | The output of an LLM or ChatModel | Depends on the parser |
-| Retriever | Single string | List of Documents |
-| Tool | Single string or dictionary, depending on the tool | Depends on the tool |
+| Component    | Input Type                                            | Output Type           |
+|--------------|-------------------------------------------------------|-----------------------|
+| Prompt       | Dictionary                                            | PromptValue           |
+| ChatModel    | Single string, list of chat messages or a PromptValue | ChatMessage           |
+| LLM          | Single string, list of chat messages or a PromptValue | String                |
+| OutputParser | The output of an LLM or ChatModel                     | Depends on the parser |
+| Retriever    | Single string                                         | List of Documents     |
+| Tool         | Single string or dictionary, depending on the tool    | Depends on the tool   |
 
 
 All runnables expose input and output **schemas** to inspect the inputs and outputs:
@@ -236,7 +236,7 @@ This is where information like log-probs and token usage may be stored.
 
 **`tool_calls`**
 
-These represent a decision from an language model to call a tool. They are included as part of an `AIMessage` output.
+These represent a decision from a language model to call a tool. They are included as part of an `AIMessage` output.
 They can be accessed from there with the `.tool_calls` property.
 
 This property returns a list of `ToolCall`s. A `ToolCall` is a dictionary with the following arguments:
@@ -256,6 +256,8 @@ This represents a message with role "tool", which contains the result of calling
 - a `tool_call_id` field which conveys the id of the call to the tool that was called to produce this result.
 - an `artifact` field which can be used to pass along arbitrary artifacts of the tool execution which are useful to track but which should not be sent to the model.
 
+With most chat models, a `ToolMessage` can only appear in the chat history after an `AIMessage` that has a populated `tool_calls` field.
+
 #### (Legacy) FunctionMessage
 
 This is a legacy message type, corresponding to OpenAI's legacy function-calling API. `ToolMessage` should be used instead to correspond to the updated tool-calling API.
@@ -732,10 +734,10 @@ of the object.
 If you're creating a custom chain or runnable, you need to remember to propagate request time
 callbacks to any child objects.
 
-:::important Async in Python<=3.10
+:::important Async in Python&lt;=3.10
 
 Any `RunnableLambda`, a `RunnableGenerator`, or `Tool` that invokes other runnables
-and is running `async` in python<=3.10, will have to propagate callbacks to child
+and is running `async` in python&lt;=3.10, will have to propagate callbacks to child
 objects manually. This is because LangChain cannot automatically propagate
 callbacks to child objects in this case.
 

docs/docs/how_to/agent_executor.ipynb

@@ -17,7 +17,7 @@
    "source": [
     "# Build an Agent with AgentExecutor (Legacy)\n",
     "\n",
-    ":::{.callout-important}\n",
+    ":::important\n",
     "This section will cover building with the legacy LangChain AgentExecutor. These are fine for getting started, but past a certain point, you will likely want flexibility and control that they do not offer. For working with more advanced agents, we'd recommend checking out [LangGraph Agents](/docs/concepts/#langgraph) or the [migration guide](/docs/how_to/migrate_agent/)\n",
     ":::\n",
     "\n",
@@ -49,7 +49,6 @@
     "\n",
     "To install LangChain run:\n",
     "\n",
-    "```{=mdx}\n",
     "import Tabs from '@theme/Tabs';\n",
     "import TabItem from '@theme/TabItem';\n",
     "import CodeBlock from \"@theme/CodeBlock\";\n",
@@ -63,7 +62,6 @@
     "  </TabItem>\n",
     "</Tabs>\n",
     "\n",
-    "```\n",
     "\n",
     "\n",
     "For more details, see our [Installation guide](/docs/how_to/installation).\n",
@@ -270,11 +268,9 @@
     "\n",
     "Next, let's learn how to use a language model by to call tools. LangChain supports many different language models that you can use interchangably - select the one you want to use below!\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
-    "<ChatModelTabs openaiParams={`model=\"gpt-4\"`} />\n",
-    "```"
+    "<ChatModelTabs openaiParams={`model=\"gpt-4\"`} />\n"
    ]
   },
   {
@@ -805,7 +801,7 @@
     "\n",
     "That's a wrap! In this quick start we covered how to create a simple agent. Agents are a complex topic, and there's lot to learn! \n",
     "\n",
-    ":::{.callout-important}\n",
+    ":::important\n",
     "This section covered building with LangChain Agents. LangChain Agents are fine for getting started, but past a certain point you will likely want flexibility and control that they do not offer. For working with more advanced agents, we'd reccommend checking out [LangGraph](/docs/concepts/#langgraph)\n",
     ":::\n",
     "\n",

docs/docs/how_to/callbacks_async.ipynb

@@ -17,11 +17,11 @@
     "If you are planning to use the async APIs, it is recommended to use and extend [`AsyncCallbackHandler`](https://python.langchain.com/api_reference/core/callbacks/langchain_core.callbacks.base.AsyncCallbackHandler.html) to avoid blocking the event.\n",
     "\n",
     "\n",
-    ":::{.callout-warning}\n",
+    ":::warning\n",
     "If you use a sync `CallbackHandler` while using an async method to run your LLM / Chain / Tool / Agent, it will still work. However, under the hood, it will be called with [`run_in_executor`](https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.loop.run_in_executor) which can cause issues if your `CallbackHandler` is not thread-safe.\n",
     ":::\n",
     "\n",
-    ":::{.callout-danger}\n",
+    ":::danger\n",
     "\n",
     "If you're on `python<=3.10`, you need to remember to propagate `config` or `callbacks` when invoking other `runnable` from within a `RunnableLambda`, `RunnableGenerator` or `@tool`. If you do not do this,\n",
     "the callbacks will not be propagated to the child runnables being invoked.\n",

docs/docs/how_to/callbacks_attach.ipynb

@@ -19,7 +19,7 @@
     "\n",
     "If you are composing a chain of runnables and want to reuse callbacks across multiple executions, you can attach callbacks with the [`.with_config()`](https://python.langchain.com/api_reference/core/runnables/langchain_core.runnables.base.Runnable.html#langchain_core.runnables.base.Runnable.with_config) method. This saves you the need to pass callbacks in each time you invoke the chain.\n",
     "\n",
-    ":::{.callout-important}\n",
+    ":::important\n",
     "\n",
     "`with_config()` binds a configuration which will be interpreted as **runtime** configuration. So these callbacks will propagate to all child components.\n",
     ":::\n",

docs/docs/how_to/callbacks_constructor.ipynb

@@ -17,7 +17,7 @@
     "\n",
     "Most LangChain modules allow you to pass `callbacks` directly into the constructor (i.e., initializer). In this case, the callbacks will only be called for that instance (and any nested runs).\n",
     "\n",
-    ":::{.callout-warning}\n",
+    ":::warning\n",
     "Constructor callbacks are scoped only to the object they are defined on. They are **not** inherited by children of the object. This can lead to confusing behavior,\n",
     "and it's generally better to pass callbacks as a run time argument.\n",
     ":::\n",

docs/docs/how_to/callbacks_custom_events.ipynb

@@ -29,7 +29,7 @@
     "| data      | Any  | The data associated with the event. This can be anything, though we suggest making it JSON serializable. |\n",
     "\n",
     "\n",
-    ":::{.callout-important}\n",
+    ":::important\n",
     "* Dispatching custom callback events requires `langchain-core>=0.2.15`.\n",
     "* Custom callback events can only be dispatched from within an existing `Runnable`.\n",
     "* If using `astream_events`, you must use `version='v2'` to see custom events.\n",
@@ -38,9 +38,9 @@
     "\n",
     "\n",
     ":::caution COMPATIBILITY\n",
-    "LangChain cannot automatically propagate configuration, including callbacks necessary for astream_events(), to child runnables if you are running async code in python<=3.10. This is a common reason why you may fail to see events being emitted from custom runnables or tools.\n",
+    "LangChain cannot automatically propagate configuration, including callbacks necessary for astream_events(), to child runnables if you are running async code in python&lt;=3.10. This is a common reason why you may fail to see events being emitted from custom runnables or tools.\n",
     "\n",
-    "If you are running python<=3.10, you will need to manually propagate the `RunnableConfig` object to the child runnable in async environments. For an example of how to manually propagate the config, see the implementation of the `bar` RunnableLambda below.\n",
+    "If you are running python&lt;=3.10, you will need to manually propagate the `RunnableConfig` object to the child runnable in async environments. For an example of how to manually propagate the config, see the implementation of the `bar` RunnableLambda below.\n",
     "\n",
     "If you are running python>=3.11, the `RunnableConfig` will automatically propagate to child runnables in async environment. However, it is still a good idea to propagate the `RunnableConfig` manually if your code may run in other Python versions.\n",
     ":::"
@@ -69,7 +69,7 @@
     "We can use the `async` `adispatch_custom_event` API to emit custom events in an async setting. \n",
     "\n",
     "\n",
-    ":::{.callout-important}\n",
+    ":::important\n",
     "\n",
     "To see custom events via the astream events API, you need to use the newer `v2` API of `astream_events`.\n",
     ":::"
@@ -115,7 +115,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "In python <= 3.10, you must propagate the config manually!"
+    "In python &lt;= 3.10, you must propagate the config manually!"
    ]
   },
   {

docs/docs/how_to/chat_model_caching.ipynb

@@ -28,11 +28,9 @@
    "id": "289b31de",
    "metadata": {},
    "source": [
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
-    "<ChatModelTabs customVarName=\"llm\" />\n",
-    "```"
+    "<ChatModelTabs customVarName=\"llm\" />\n"
    ]
   },
   {

docs/docs/how_to/chat_streaming.ipynb

@@ -22,7 +22,7 @@
     "\n",
     "The **default** streaming implementation provides an`Iterator` (or `AsyncIterator` for asynchronous streaming) that yields a single value: the final output from the underlying chat model provider.\n",
     "\n",
-    ":::{.callout-tip}\n",
+    ":::tip\n",
     "\n",
     "The **default** implementation does **not** provide support for token-by-token streaming, but it ensures that the the model can be swapped in for any other model as it supports the same standard interface.\n",
     "\n",

docs/docs/how_to/chat_token_usage_tracking.ipynb

@@ -155,11 +155,9 @@
     "\n",
     "For example, OpenAI will return a message [chunk](https://python.langchain.com/api_reference/core/messages/langchain_core.messages.ai.AIMessageChunk.html) at the end of a stream with token usage information. This behavior is supported by `langchain-openai >= 0.1.9` and can be enabled by setting `stream_usage=True`. This attribute can also be set when `ChatOpenAI` is instantiated.\n",
     "\n",
-    "```{=mdx}\n",
     ":::note\n",
     "By default, the last message chunk in a stream will include a `\"finish_reason\"` in the message's `response_metadata` attribute. If we include token usage in streaming mode, an additional chunk containing usage metadata will be added to the end of the stream, such that `\"finish_reason\"` appears on the second to last message chunk.\n",
-    ":::\n",
-    "```"
+    ":::\n"
    ]
   },
   {

docs/docs/how_to/convert_runnable_to_tool.ipynb

@@ -266,11 +266,9 @@
     "\n",
     "We first instantiate a chat model that supports [tool calling](/docs/how_to/tool_calling/):\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
-    "<ChatModelTabs customVarName=\"llm\" />\n",
-    "```"
+    "<ChatModelTabs customVarName=\"llm\" />\n"
    ]
   },
   {

docs/docs/how_to/custom_chat_model.ipynb

@@ -39,7 +39,7 @@
     "| `AIMessageChunk` / `HumanMessageChunk` / ... | Chunk variant of each type of message. |\n",
     "\n",
     "\n",
-    "::: {.callout-note}\n",
+    ":::note\n",
     "`ToolMessage` and `FunctionMessage` closely follow OpenAI's `function` and `tool` roles.\n",
     "\n",
     "This is a rapidly developing field and as more models add function calling capabilities. Expect that there will be additions to this schema.\n",
@@ -145,7 +145,7 @@
     "| `_astream`                         | Use to implement async version of `_stream`.                      | Optional           |\n",
     "\n",
     "\n",
-    ":::{.callout-tip}\n",
+    ":::tip\n",
     "The `_astream` implementation uses `run_in_executor` to launch the sync `_stream` in a separate thread if `_stream` is implemented, otherwise it fallsback to use `_agenerate`.\n",
     "\n",
     "You can use this trick if you want to reuse the `_stream` implementation, but if you're able to implement code that's natively async that's a better solution since that code will run with less overhead.\n",

docs/docs/how_to/custom_retriever.ipynb

@@ -37,12 +37,12 @@
     "\n",
     "The logic inside of `_get_relevant_documents` can involve arbitrary calls to a database or to the web using requests.\n",
     "\n",
-    ":::{.callout-tip}\n",
+    ":::tip\n",
     "By inherting from `BaseRetriever`, your retriever automatically becomes a LangChain [Runnable](/docs/concepts#interface) and will gain the standard `Runnable` functionality out of the box!\n",
     ":::\n",
     "\n",
     "\n",
-    ":::{.callout-info}\n",
+    ":::info\n",
     "You can use a `RunnableLambda` or `RunnableGenerator` to implement a retriever.\n",
     "\n",
     "The main benefit of implementing a retriever as a `BaseRetriever` vs. a `RunnableLambda` (a custom [runnable function](/docs/how_to/functions)) is that a `BaseRetriever` is a well\n",

docs/docs/how_to/custom_tools.ipynb

@@ -26,7 +26,7 @@
     "\n",
     "In this guide we provide an overview of these methods.\n",
     "\n",
-    ":::{.callout-tip}\n",
+    ":::tip\n",
     "\n",
     "Models will perform better if the tools have well chosen names, descriptions and JSON schemas.\n",
     ":::"
@@ -293,7 +293,7 @@
    "id": "f18a2503-5393-421b-99fa-4a01dd824d0e",
    "metadata": {},
    "source": [
-    ":::{.callout-caution}\n",
+    ":::caution\n",
     "By default, `@tool(parse_docstring=True)` will raise `ValueError` if the docstring does not parse correctly. See [API Reference](https://python.langchain.com/api_reference/core/tools/langchain_core.tools.tool.html) for detail and examples.\n",
     ":::"
    ]

docs/docs/how_to/debugging.ipynb

@@ -49,13 +49,11 @@
     "\n",
     "Let's suppose we have an agent, and want to visualize the actions it takes and tool outputs it receives. Without any debugging, here's what we see:\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
     "<ChatModelTabs\n",
     "  customVarName=\"llm\"\n",
-    "/>\n",
-    "```"
+    "/>\n"
    ]
   },
   {

docs/docs/how_to/document_loader_custom.ipynb

@@ -63,7 +63,7 @@
     "* The `load` methods is a convenience method meant solely for prototyping work -- it just invokes `list(self.lazy_load())`.\n",
     "* The `alazy_load` has a default implementation that will delegate to `lazy_load`. If you're using async, we recommend overriding the default implementation and providing a native async implementation.\n",
     "\n",
-    ":::{.callout-important}\n",
+    ":::important\n",
     "When implementing a document loader do **NOT** provide parameters via the `lazy_load` or `alazy_load` methods.\n",
     "\n",
     "All configuration is expected to be passed through the initializer (__init__). This was a design choice made by LangChain to make sure that once a document loader has been instantiated it has all the information needed to load documents.\n",
@@ -235,7 +235,7 @@
    "id": "56cb443e-f987-4386-b4ec-975ee129adb2",
    "metadata": {},
    "source": [
-    ":::{.callout-tip}\n",
+    ":::tip\n",
     "\n",
     "`load()` can be helpful in an interactive environment such as a jupyter notebook.\n",
     "\n",

docs/docs/how_to/document_loader_json.mdx

@@ -41,10 +41,7 @@ data = json.loads(Path(file_path).read_text())
 ```python
 pprint(data)
 ```
-
-<CodeOutputBlock lang="python">
-
-```
+```output
     {'image': {'creation_timestamp': 1675549016, 'uri': 'image_of_the_chat.jpg'},
      'is_still_participant': True,
      'joinable_mode': {'link': '', 'mode': 1},
@@ -91,7 +88,6 @@ pprint(data)
      'title': 'User 1 and User 2 chat'}
 ```
 
-</CodeOutputBlock>
 
 
 ## Using `JSONLoader`
@@ -115,9 +111,7 @@ data = loader.load()
 pprint(data)
 ```
 
-<CodeOutputBlock lang="python">
-
-```
+```output
     [Document(page_content='Bye!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 1}),
      Document(page_content='Oh no worries! Bye', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 2}),
      Document(page_content='No Im sorry it was my mistake, the blue one is not for sale', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 3}),
@@ -131,7 +125,6 @@ pprint(data)
      Document(page_content='Hi! Im interested in your bag. Im offering $50. Let me know if you are interested. Thanks!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 11})]
 ```
 
-</CodeOutputBlock>
 
 
 ### JSON Lines file
@@ -144,9 +137,7 @@ file_path = './example_data/facebook_chat_messages.jsonl'
 pprint(Path(file_path).read_text())
 ```
 
-<CodeOutputBlock lang="python">
-
-```
+```output
     ('{"sender_name": "User 2", "timestamp_ms": 1675597571851, "content": "Bye!"}\n'
      '{"sender_name": "User 1", "timestamp_ms": 1675597435669, "content": "Oh no '
      'worries! Bye"}\n'
@@ -154,7 +145,6 @@ pprint(Path(file_path).read_text())
      'sorry it was my mistake, the blue one is not for sale"}\n')
 ```
 
-</CodeOutputBlock>
 
 
 ```python
@@ -171,15 +161,12 @@ data = loader.load()
 pprint(data)
 ```
 
-<CodeOutputBlock lang="python">
-
-```
+```output
     [Document(page_content='Bye!', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat_messages.jsonl', 'seq_num': 1}),
      Document(page_content='Oh no worries! Bye', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat_messages.jsonl', 'seq_num': 2}),
      Document(page_content='No Im sorry it was my mistake, the blue one is not for sale', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat_messages.jsonl', 'seq_num': 3})]
 ```
 
-</CodeOutputBlock>
 
 
 Another option is to set `jq_schema='.'` and provide `content_key`:
@@ -198,15 +185,12 @@ data = loader.load()
 pprint(data)
 ```
 
-<CodeOutputBlock lang="python">
-
-```
+```output
     [Document(page_content='User 2', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat_messages.jsonl', 'seq_num': 1}),
      Document(page_content='User 1', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat_messages.jsonl', 'seq_num': 2}),
      Document(page_content='User 2', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat_messages.jsonl', 'seq_num': 3})]
 ```
 
-</CodeOutputBlock>
 
 ### JSON file with jq schema `content_key`
 
@@ -218,9 +202,7 @@ file_path = './sample.json'
 pprint(Path(file_path).read_text())
 ```
 
-<CodeOutputBlock lang="python">
-
-```json
+```outputjson
     {"data": [
         {"attributes": {
             "message": "message1",
@@ -234,7 +216,6 @@ pprint(Path(file_path).read_text())
         "id": "2"}]}
 ```
 
-</CodeOutputBlock>
 
 
 ```python
@@ -252,14 +233,11 @@ data = loader.load()
 pprint(data)
 ```
 
-<CodeOutputBlock lang="python">
-
-```
+```output
     [Document(page_content='message1', metadata={'source': '/path/to/sample.json', 'seq_num': 1}),
      Document(page_content='message2', metadata={'source': '/path/to/sample.json', 'seq_num': 2})]
 ```
 
-</CodeOutputBlock>
 
 ## Extracting metadata
 
@@ -309,9 +287,7 @@ data = loader.load()
 pprint(data)
 ```
 
-<CodeOutputBlock lang="python">
-
-```
+```output
     [Document(page_content='Bye!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 1, 'sender_name': 'User 2', 'timestamp_ms': 1675597571851}),
      Document(page_content='Oh no worries! Bye', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 2, 'sender_name': 'User 1', 'timestamp_ms': 1675597435669}),
      Document(page_content='No Im sorry it was my mistake, the blue one is not for sale', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 3, 'sender_name': 'User 2', 'timestamp_ms': 1675596277579}),
@@ -325,7 +301,6 @@ pprint(data)
      Document(page_content='Hi! Im interested in your bag. Im offering $50. Let me know if you are interested. Thanks!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 11, 'sender_name': 'User 1', 'timestamp_ms': 1675549022673})]
 ```
 
-</CodeOutputBlock>
 
 Now, you will see that the documents contain the metadata associated with the content we extracted.
 
@@ -368,9 +343,7 @@ data = loader.load()
 pprint(data)
 ```
 
-<CodeOutputBlock lang="python">
-
-```
+```output
     [Document(page_content='Bye!', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 1, 'sender_name': 'User 2', 'timestamp_ms': 1675597571851}),
      Document(page_content='Oh no worries! Bye', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 2, 'sender_name': 'User 1', 'timestamp_ms': 1675597435669}),
      Document(page_content='No Im sorry it was my mistake, the blue one is not for sale', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 3, 'sender_name': 'User 2', 'timestamp_ms': 1675596277579}),
@@ -384,7 +357,6 @@ pprint(data)
      Document(page_content='Hi! Im interested in your bag. Im offering $50. Let me know if you are interested. Thanks!', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 11, 'sender_name': 'User 1', 'timestamp_ms': 1675549022673})]
 ```
 
-</CodeOutputBlock>
 
 ## Common JSON structures with jq schema
 

docs/docs/how_to/document_loader_web.ipynb

@@ -0,0 +1,486 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "7414502a-4532-4da3-aef0-71aac4d0d4dd",
+   "metadata": {},
+   "source": [
+    "# How to load web pages\n",
+    "\n",
+    "This guide covers how to load web pages into the LangChain [Document](https://python.langchain.com/api_reference/core/documents/langchain_core.documents.base.Document.html) format that we use downstream. Web pages contain text, images, and other multimedia elements, and are typically represented with HTML. They may include links to other pages or resources.\n",
+    "\n",
+    "LangChain integrates with a host of parsers that are appropriate for web pages. The right parser will depend on your needs. Below we demonstrate two possibilities:\n",
+    "\n",
+    "- [Simple and fast](/docs/how_to/document_loader_web#simple-and-fast-text-extraction) parsing, in which we recover one `Document` per web page with its content represented as a \"flattened\" string;\n",
+    "- [Advanced](/docs/how_to/document_loader_web#advanced-parsing) parsing, in which we recover multiple `Document` objects per page, allowing one to identify and traverse sections, links, tables, and other structures.\n",
+    "\n",
+    "## Setup\n",
+    "\n",
+    "For the \"simple and fast\" parsing, we will need `langchain-community` and the `beautifulsoup4` library:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "89bc7be9-ab50-4c5a-860a-deee7b469f67",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%pip install -qU langchain-community beautifulsoup4"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a07f5ca3-e2b7-4d9c-b1f2-7547856cbdf7",
+   "metadata": {},
+   "source": [
+    "For advanced parsing, we will use `langchain-unstructured`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8a3ef1fc-dfde-4814-b7f6-b6c0c649f044",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%pip install -qU langchain-unstructured"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4ef11005-1bd0-43a3-8d52-ea823c830c34",
+   "metadata": {},
+   "source": [
+    "## Simple and fast text extraction\n",
+    "\n",
+    "If you are looking for a simple string representation of text that is embedded in a web page, the method below is appropriate. It will return a list of `Document` objects -- one per page -- containing a single string of the page's text. Under the hood it uses the `beautifulsoup4` Python library.\n",
+    "\n",
+    "LangChain document loaders implement `lazy_load` and its async variant, `alazy_load`, which return iterators of `Document objects`. We will use these below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "7faeccbc-4e56-4b88-99db-2274ed0680c1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "USER_AGENT environment variable not set, consider setting it to identify your requests.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import bs4\n",
+    "from langchain_community.document_loaders import WebBaseLoader\n",
+    "\n",
+    "page_url = \"https://python.langchain.com/docs/how_to/chatbots_memory/\"\n",
+    "\n",
+    "loader = WebBaseLoader(web_paths=[page_url])\n",
+    "docs = []\n",
+    "async for doc in loader.alazy_load():\n",
+    "    docs.append(doc)\n",
+    "\n",
+    "assert len(docs) == 1\n",
+    "doc = docs[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "21199a0d-3bd2-4410-a060-763649b14691",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'source': 'https://python.langchain.com/docs/how_to/chatbots_memory/', 'title': 'How to add memory to chatbots | \\uf8ffü¶úÔ∏è\\uf8ffüîó LangChain', 'description': 'A key feature of chatbots is their ability to use content of previous conversation turns as context. This state management can take several forms, including:', 'language': 'en'}\n",
+      "\n",
+      "How to add memory to chatbots | 🦜️🔗 LangChain\n",
+      "\n",
+      "\n",
+      "\n",
+      "\n",
+      "\n",
+      "\n",
+      "\n",
+      "Skip to main contentShare your thoughts on AI agents. Take the 3-min survey.IntegrationsAPI ReferenceMoreContributingPeopleLangSmithLangGraphLangChain HubLangChain JS/TSv0.3v0.3v0.2v0.1💬SearchIntroductionTutorialsBuild a Question Answering application over a Graph DatabaseTutorialsBuild a Simple LLM Application with LCELBuild a Query Analysis SystemBuild a ChatbotConversational RAGBuild an Extraction ChainBuild an AgentTaggingd\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"{doc.metadata}\\n\")\n",
+    "print(doc.page_content[:500].strip())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "23189e91-5237-4a9e-a4bb-cb79e130c364",
+   "metadata": {},
+   "source": [
+    "This is essentially a dump of the text from the page's HTML. It may contain extraneous information like headings and navigation bars. If you are familiar with the expected HTML, you can specify desired `<div>` classes and other parameters via BeautifulSoup. Below we parse only the body text of the article:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "4211b1a6-e636-415b-a556-ae01969399a7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loader = WebBaseLoader(\n",
+    "    web_paths=[page_url],\n",
+    "    bs_kwargs={\n",
+    "        \"parse_only\": bs4.SoupStrainer(class_=\"theme-doc-markdown markdown\"),\n",
+    "    },\n",
+    "    bs_get_text_kwargs={\"separator\": \" | \", \"strip\": True},\n",
+    ")\n",
+    "\n",
+    "docs = []\n",
+    "async for doc in loader.alazy_load():\n",
+    "    docs.append(doc)\n",
+    "\n",
+    "assert len(docs) == 1\n",
+    "doc = docs[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "7edf6ed0-e22f-4c64-b986-8ba019c14757",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'source': 'https://python.langchain.com/docs/how_to/chatbots_memory/'}\n",
+      "\n",
+      "How to add memory to chatbots | A key feature of chatbots is their ability to use content of previous conversation turns as context. This state management can take several forms, including: | Simply stuffing previous messages into a chat model prompt. | The above, but trimming old messages to reduce the amount of distracting information the model has to deal with. | More complex modifications like synthesizing summaries for long running conversations. | We'll go into more detail on a few techniq\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"{doc.metadata}\\n\")\n",
+    "print(doc.page_content[:500])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "6ab1ba2b-3b22-4c5d-8ad3-f6809d075d26",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "a greeting. Nemo then asks the AI how it is doing, and the AI responds that it is fine.'), | HumanMessage(content='What did I say my name was?'), | AIMessage(content='You introduced yourself as Nemo. How can I assist you today, Nemo?')] | Note that invoking the chain again will generate another summary generated from the initial summary plus new messages and so on. You could also design a hybrid approach where a certain number of messages are retained in chat history while others are summarized.\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(doc.page_content[-500:])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0a411144-a234-4505-956c-930d399ffefb",
+   "metadata": {},
+   "source": [
+    "Note that this required advance technical knowledge of how the body text is represented in the underlying HTML.\n",
+    "\n",
+    "We can parameterize `WebBaseLoader` with a variety of settings, allowing for specification of request headers, rate limits, and parsers and other kwargs for BeautifulSoup. See its [API reference](https://python.langchain.com/api_reference/community/document_loaders/langchain_community.document_loaders.web_base.WebBaseLoader.html) for detail."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cdfc8f68-2b08-4a6c-9705-c17e6deaf411",
+   "metadata": {},
+   "source": [
+    "## Advanced parsing\n",
+    "\n",
+    "This method is appropriate if we want more granular control or processing of the page content. Below, instead of generating one `Document` per page and controlling its content via BeautifulSoup, we generate multiple `Document` objects representing distinct structures on a page. These structures can include section titles and their corresponding body texts, lists or enumerations, tables, and more.\n",
+    "\n",
+    "Under the hood it uses the `langchain-unstructured` library. See the [integration docs](/docs/integrations/document_loaders/unstructured_file/) for more information about using [Unstructured](https://docs.unstructured.io/welcome) with LangChain."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "7a6bbfef-ebd5-4357-a7f5-9c989dda092d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO: Note: NumExpr detected 12 cores but \"NUMEXPR_MAX_THREADS\" not set, so enforcing safe limit of 8.\n",
+      "INFO: NumExpr defaulting to 8 threads.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain_unstructured import UnstructuredLoader\n",
+    "\n",
+    "page_url = \"https://python.langchain.com/docs/how_to/chatbots_memory/\"\n",
+    "loader = UnstructuredLoader(web_url=page_url)\n",
+    "\n",
+    "docs = []\n",
+    "async for doc in loader.alazy_load():\n",
+    "    docs.append(doc)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "53a600b0-fcd2-4074-80b6-a1dd2c0d9235",
+   "metadata": {},
+   "source": [
+    "Note that with no advance knowledge of the page HTML structure, we recover a natural organization of the body text:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "198b7469-587f-4a80-a49f-440e6157b241",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "How to add memory to chatbots\n",
+      "A key feature of chatbots is their ability to use content of previous conversation turns as context. This state management can take several forms, including:\n",
+      "Simply stuffing previous messages into a chat model prompt.\n",
+      "The above, but trimming old messages to reduce the amount of distracting information the model has to deal with.\n",
+      "More complex modifications like synthesizing summaries for long running conversations.\n",
+      "ERROR! Session/line number was not unique in database. History logging moved to new session 2747\n"
+     ]
+    }
+   ],
+   "source": [
+    "for doc in docs[:5]:\n",
+    "    print(doc.page_content)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3f4254b5-5e3b-45c4-9cd0-7ed753687783",
+   "metadata": {},
+   "source": [
+    "### Extracting content from specific sections"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "627d9b7a-31fe-4923-bc9a-4b0caae1d760",
+   "metadata": {},
+   "source": [
+    "Each `Document` object represents an element of the page. Its metadata contains useful information, such as its category:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "2fa19a61-a53d-42e0-a01a-7ea99fc40810",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Title: How to add memory to chatbots\n",
+      "NarrativeText: A key feature of chatbots is their ability to use content of previous conversation turns as context. This state management can take several forms, including:\n",
+      "ListItem: Simply stuffing previous messages into a chat model prompt.\n",
+      "ListItem: The above, but trimming old messages to reduce the amount of distracting information the model has to deal with.\n",
+      "ListItem: More complex modifications like synthesizing summaries for long running conversations.\n"
+     ]
+    }
+   ],
+   "source": [
+    "for doc in docs[:5]:\n",
+    "    print(f'{doc.metadata[\"category\"]}: {doc.page_content}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ca0f8025-58b8-4d2a-95aa-124d7a8ee812",
+   "metadata": {},
+   "source": [
+    "Elements may also have parent-child relationships -- for example, a paragraph might belong to a section with a title. If a section is of particular interest (e.g., for indexing) we can isolate the corresponding `Document` objects.\n",
+    "\n",
+    "As an example, below we load the content of the \"Setup\" sections for two web pages:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "793018fd-1365-4a8a-8690-6d51dad2e1cf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from typing import List\n",
+    "\n",
+    "from langchain_core.documents import Document\n",
+    "\n",
+    "\n",
+    "async def _get_setup_docs_from_url(url: str) -> List[Document]:\n",
+    "    loader = UnstructuredLoader(web_url=url)\n",
+    "\n",
+    "    setup_docs = []\n",
+    "    parent_id = -1\n",
+    "    async for doc in loader.alazy_load():\n",
+    "        if doc.metadata[\"category\"] == \"Title\" and doc.page_content.startswith(\"Setup\"):\n",
+    "            parent_id = doc.metadata[\"element_id\"]\n",
+    "        if doc.metadata.get(\"parent_id\") == parent_id:\n",
+    "            setup_docs.append(doc)\n",
+    "\n",
+    "    return setup_docs\n",
+    "\n",
+    "\n",
+    "page_urls = [\n",
+    "    \"https://python.langchain.com/docs/how_to/chatbots_memory/\",\n",
+    "    \"https://python.langchain.com/docs/how_to/chatbots_tools/\",\n",
+    "]\n",
+    "setup_docs = []\n",
+    "for url in page_urls:\n",
+    "    page_setup_docs = await _get_setup_docs_from_url(url)\n",
+    "    setup_docs.extend(page_setup_docs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "a67e0745-abfc-4baa-94b3-2e8815bfa52a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'https://python.langchain.com/docs/how_to/chatbots_memory/': \"You'll need to install a few packages, and have your OpenAI API key set as an environment variable named OPENAI_API_KEY:\\n%pip install --upgrade --quiet langchain langchain-openai\\n\\n# Set env var OPENAI_API_KEY or load from a .env file:\\nimport dotenv\\n\\ndotenv.load_dotenv()\\n[33mWARNING: You are using pip version 22.0.4; however, version 23.3.2 is available.\\nYou should consider upgrading via the '/Users/jacoblee/.pyenv/versions/3.10.5/bin/python -m pip install --upgrade pip' command.[0m[33m\\n[0mNote: you may need to restart the kernel to use updated packages.\\n\",\n",
+       " 'https://python.langchain.com/docs/how_to/chatbots_tools/': \"For this guide, we'll be using a tool calling agent with a single tool for searching the web. The default will be powered by Tavily, but you can switch it out for any similar tool. The rest of this section will assume you're using Tavily.\\nYou'll need to sign up for an account on the Tavily website, and install the following packages:\\n%pip install --upgrade --quiet langchain-community langchain-openai tavily-python\\n\\n# Set env var OPENAI_API_KEY or load from a .env file:\\nimport dotenv\\n\\ndotenv.load_dotenv()\\nYou will also need your OpenAI key set as OPENAI_API_KEY and your Tavily API key set as TAVILY_API_KEY.\\n\"}"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from collections import defaultdict\n",
+    "\n",
+    "setup_text = defaultdict(str)\n",
+    "\n",
+    "for doc in setup_docs:\n",
+    "    url = doc.metadata[\"url\"]\n",
+    "    setup_text[url] += f\"{doc.page_content}\\n\"\n",
+    "\n",
+    "dict(setup_text)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5cd42892-24a6-4969-92c8-c928680be9b5",
+   "metadata": {},
+   "source": [
+    "### Vector search over page content\n",
+    "\n",
+    "Once we have loaded the page contents into LangChain `Document` objects, we can index them (e.g., for a RAG application) in the usual way. Below we use OpenAI [embeddings](/docs/concepts/#embedding-models), although any LangChain embeddings model will suffice."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5a6cbb01-6e0d-418f-9f76-2031622bebb0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%pip install -qU langchain-openai"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "598e612c-180d-494d-8caa-761c89f84eae",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import getpass\n",
+    "import os\n",
+    "\n",
+    "if \"OPENAI_API_KEY\" not in os.environ:\n",
+    "    os.environ[\"OPENAI_API_KEY\"] = getpass.getpass(\"OpenAI API Key:\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "5eeaeb54-ea03-4634-8a79-b60c22ab2b66",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO: HTTP Request: POST https://api.openai.com/v1/embeddings \"HTTP/1.1 200 OK\"\n",
+      "INFO: HTTP Request: POST https://api.openai.com/v1/embeddings \"HTTP/1.1 200 OK\"\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Page https://python.langchain.com/docs/how_to/chatbots_tools/: You'll need to sign up for an account on the Tavily website, and install the following packages:\n",
+      "\n",
+      "Page https://python.langchain.com/docs/how_to/chatbots_tools/: For this guide, we'll be using a tool calling agent with a single tool for searching the web. The default will be powered by Tavily, but you can switch it out for any similar tool. The rest of this section will assume you're using Tavily.\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain_core.vectorstores import InMemoryVectorStore\n",
+    "from langchain_openai import OpenAIEmbeddings\n",
+    "\n",
+    "vector_store = InMemoryVectorStore.from_documents(setup_docs, OpenAIEmbeddings())\n",
+    "retrieved_docs = vector_store.similarity_search(\"Install Tavily\", k=2)\n",
+    "for doc in retrieved_docs:\n",
+    "    print(f'Page {doc.metadata[\"url\"]}: {doc.page_content[:300]}\\n')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "67be9c94-dbde-4fdd-87d0-e83ed6066d2b",
+   "metadata": {},
+   "source": [
+    "## Other web page loaders\n",
+    "\n",
+    "For a list of available LangChain web page loaders, please see [this table](/docs/integrations/document_loaders/#webpages)."
+   ]
+  }
+ ],
+ "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.10.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/docs/how_to/dynamic_chain.ipynb

@@ -17,13 +17,11 @@
     "\n",
     "Sometimes we want to construct parts of a chain at runtime, depending on the chain inputs ([routing](/docs/how_to/routing/) is the most common example of this). We can create dynamic chains like this using a very useful property of RunnableLambda's, which is that if a RunnableLambda returns a Runnable, that Runnable is itself invoked. Let's see an example.\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
     "<ChatModelTabs\n",
     "  customVarName=\"llm\"\n",
-    "/>\n",
-    "```"
+    "/>\n"
    ]
   },
   {

docs/docs/how_to/embed_text.mdx

@@ -115,13 +115,10 @@ embeddings = embeddings_model.embed_documents(
 len(embeddings), len(embeddings[0])
 ```
 
-<CodeOutputBlock language="python">
-
-```
+```output
 (5, 1536)
 ```
 
-</CodeOutputBlock>
 
 ### `embed_query`
 #### Embed single query
@@ -132,9 +129,7 @@ embedded_query = embeddings_model.embed_query("What was the name mentioned in th
 embedded_query[:5]
 ```
 
-<CodeOutputBlock language="python">
-
-```
+```output
 [0.0053587136790156364,
  -0.0004999046213924885,
  0.038883671164512634,
@@ -142,4 +137,3 @@ embedded_query[:5]
  -0.00900818221271038]
 ```
 
-</CodeOutputBlock>

docs/docs/how_to/extraction_examples.ipynb

@@ -11,7 +11,7 @@
     "\n",
     "Data extraction attempts to generate structured representations of information found in text and other unstructured or semi-structured formats. [Tool-calling](/docs/concepts#functiontool-calling) LLM features are often used in this context. This guide demonstrates how to build few-shot examples of tool calls to help steer the behavior of extraction and similar applications.\n",
     "\n",
-    ":::{.callout-tip}\n",
+    ":::tip\n",
     "While this guide focuses how to use examples with a tool calling model, this technique is generally applicable, and will work\n",
     "also with JSON more or prompt based techniques.\n",
     ":::\n",
@@ -172,7 +172,7 @@
     "\n",
     "Each example contains an example `input` text and an example `output` showing what should be extracted from the text.\n",
     "\n",
-    ":::{.callout-important}\n",
+    ":::important\n",
     "This is a bit in the weeds, so feel free to skip.\n",
     "\n",
     "The format of the example needs to match the API used (e.g., tool calling or JSON mode etc.).\n",
@@ -350,14 +350,12 @@
     "\n",
     "Let's select an LLM. Because we are using tool-calling, we will need a model that supports a tool-calling feature. See [this table](/docs/integrations/chat) for available LLMs.\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
     "<ChatModelTabs\n",
     "  customVarName=\"llm\"\n",
     "  openaiParams={`model=\"gpt-4-0125-preview\", temperature=0`}\n",
-    "/>\n",
-    "```"
+    "/>\n"
    ]
   },
   {

docs/docs/how_to/extraction_long_text.ipynb

@@ -196,14 +196,12 @@
     "\n",
     "Let's select an LLM. Because we are using tool-calling, we will need a model that supports a tool-calling feature. See [this table](/docs/integrations/chat) for available LLMs.\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
     "<ChatModelTabs\n",
     "  customVarName=\"llm\"\n",
     "  openaiParams={`model=\"gpt-4-0125-preview\", temperature=0`}\n",
-    "/>\n",
-    "```"
+    "/>\n"
    ]
   },
   {
@@ -291,7 +289,7 @@
    "source": [
     "Use [batch](https://python.langchain.com/api_reference/core/runnables/langchain_core.runnables.base.Runnable.html) functionality to run the extraction in **parallel** across each chunk! \n",
     "\n",
-    ":::{.callout-tip}\n",
+    ":::tip\n",
     "You can often use .batch() to parallelize the extractions! `.batch` uses a threadpool under the hood to help you parallelize workloads.\n",
     "\n",
     "If your model is exposed via an API, this will likely speed up your extraction flow!\n",
@@ -382,7 +380,7 @@
     "\n",
     "Another simple idea is to chunk up the text, but instead of extracting information from every chunk, just focus on the the most relevant chunks.\n",
     "\n",
-    ":::{.callout-caution}\n",
+    ":::caution\n",
     "It can be difficult to identify which chunks are relevant.\n",
     "\n",
     "For example, in the `car` article we're using here, most of the article contains key development information. So by using\n",

docs/docs/how_to/extraction_parse.ipynb

@@ -18,11 +18,9 @@
     "\n",
     "First we select a LLM:\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
-    "<ChatModelTabs customVarName=\"model\" />\n",
-    "```"
+    "<ChatModelTabs customVarName=\"model\" />\n"
    ]
   },
   {
@@ -52,7 +50,7 @@
    "id": "3e412374-3beb-4bbf-966b-400c1f66a258",
    "metadata": {},
    "source": [
-    ":::{.callout-tip}\n",
+    ":::tip\n",
     "This tutorial is meant to be simple, but generally should really include reference examples to squeeze out performance!\n",
     ":::"
    ]

docs/docs/how_to/function_calling.ipynb

@@ -17,14 +17,12 @@
    "source": [
     "# How to do tool/function calling\n",
     "\n",
-    "```{=mdx}\n",
     ":::info\n",
     "We use the term tool calling interchangeably with function calling. Although\n",
     "function calling is sometimes meant to refer to invocations of a single function,\n",
     "we treat all models as though they can return multiple tool or function calls in \n",
     "each message.\n",
     ":::\n",
-    "```\n",
     "\n",
     "Tool calling allows a model to respond to a given prompt by generating output that \n",
     "matches a user-defined schema. While the name implies that the model is performing \n",
@@ -165,14 +163,12 @@
    "source": [
     "We can bind them to chat models as follows:\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
     "<ChatModelTabs\n",
     "  customVarName=\"llm\"\n",
     "  fireworksParams={`model=\"accounts/fireworks/models/firefunction-v1\", temperature=0`}\n",
     "/>\n",
-    "```\n",
     "\n",
     "We can use the `bind_tools()` method to handle converting\n",
     "`Multiply` to a \"tool\" and binding it to the model (i.e.,\n",

docs/docs/how_to/functions.ipynb

@@ -303,7 +303,7 @@
    "source": [
     "## Streaming\n",
     "\n",
-    ":::{.callout-note}\n",
+    ":::note\n",
     "[RunnableLambda](https://python.langchain.com/api_reference/core/runnables/langchain_core.runnables.base.RunnableLambda.html) is best suited for code that does not need to support streaming. If you need to support streaming (i.e., be able to operate on chunks of inputs and yield chunks of outputs), use [RunnableGenerator](https://python.langchain.com/api_reference/core/runnables/langchain_core.runnables.base.RunnableGenerator.html) instead as in the example below.\n",
     ":::\n",
     "\n",

docs/docs/how_to/index.mdx

@@ -126,13 +126,14 @@ What LangChain calls [LLMs](/docs/concepts/#llms) are older forms of language mo
 
 [Document Loaders](/docs/concepts/#document-loaders) are responsible for loading documents from a variety of sources.
 
+- [How to: load PDF files](/docs/how_to/document_loader_pdf)
+- [How to: load web pages](/docs/how_to/document_loader_web)
 - [How to: load CSV data](/docs/how_to/document_loader_csv)
 - [How to: load data from a directory](/docs/how_to/document_loader_directory)
 - [How to: load HTML data](/docs/how_to/document_loader_html)
 - [How to: load JSON data](/docs/how_to/document_loader_json)
 - [How to: load Markdown data](/docs/how_to/document_loader_markdown)
 - [How to: load Microsoft Office data](/docs/how_to/document_loader_office_file)
-- [How to: load PDF files](/docs/how_to/document_loader_pdf)
 - [How to: write a custom document loader](/docs/how_to/document_loader_custom)
 
 ### Text splitters

docs/docs/how_to/llm_token_usage_tracking.ipynb

@@ -30,7 +30,7 @@
     "\n",
     "Let's first look at an extremely simple example of tracking token usage for a single Chat model call.\n",
     "\n",
-    ":::{.callout-danger}\n",
+    ":::danger\n",
     "\n",
     "The callback handler does not currently support streaming token counts for legacy language models (e.g., `langchain_openai.OpenAI`). For support in a streaming context, refer to the corresponding guide for chat models [here](/docs/how_to/chat_token_usage_tracking).\n",
     "\n",
@@ -162,7 +162,7 @@
    "source": [
     "## Streaming\n",
     "\n",
-    ":::{.callout-danger}\n",
+    ":::danger\n",
     "\n",
     "`get_openai_callback` does not currently support streaming token counts for legacy language models (e.g., `langchain_openai.OpenAI`). If you want to count tokens correctly in a streaming context, there are a number of options:\n",
     "\n",

docs/docs/how_to/local_llms.ipynb

@@ -208,7 +208,7 @@
     "\n",
     "Metal is a graphics and compute API created by Apple providing near-direct access to the GPU. \n",
     "\n",
-    "See the [`llama.cpp`](docs/integrations/llms/llamacpp) setup [here](https://github.com/abetlen/llama-cpp-python/blob/main/docs/install/macos.md) to enable this.\n",
+    "See the [`llama.cpp`](/docs/integrations/llms/llamacpp) setup [here](https://github.com/abetlen/llama-cpp-python/blob/main/docs/install/macos.md) to enable this.\n",
     "\n",
     "In particular, ensure that conda is using the correct virtual environment that you created (`miniforge3`).\n",
     "\n",

docs/docs/how_to/message_history.ipynb

@@ -155,13 +155,11 @@
     "\n",
     "First we construct a runnable (which here accepts a dict as input and returns a message as output):\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
     "<ChatModelTabs\n",
     "  customVarName=\"llm\"\n",
-    "/>\n",
-    "```"
+    "/>\n"
    ]
   },
   {

docs/docs/how_to/multi_vector.ipynb

@@ -246,11 +246,9 @@
     "\n",
     "We construct a simple [chain](/docs/how_to/sequence) that will receive an input [Document](https://python.langchain.com/api_reference/core/documents/langchain_core.documents.base.Document.html) object and generate a summary using a LLM.\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
-    "<ChatModelTabs customVarName=\"llm\" />\n",
-    "```"
+    "<ChatModelTabs customVarName=\"llm\" />\n"
    ]
   },
   {

docs/docs/how_to/output_parser_custom.ipynb

@@ -71,7 +71,7 @@
    "id": "eed8baf2-f4c2-44c1-b47d-e9f560af6202",
    "metadata": {},
    "source": [
-    ":::{.callout-tip}\n",
+    ":::tip\n",
     "\n",
     "LCEL automatically upgrades the function `parse` to `RunnableLambda(parse)` when composed using a `|`  syntax.\n",
     "\n",
@@ -140,7 +140,7 @@
    "id": "62192808-c7e1-4b3a-85f4-b7901de7c0b8",
    "metadata": {},
    "source": [
-    ":::{.callout-important}\n",
+    ":::important\n",
     "\n",
     "Please wrap the streaming parser in `RunnableGenerator` as we may stop automatically upgrading it with the `|` syntax.\n",
     ":::"
@@ -219,7 +219,7 @@
     "\n",
     "When the output from the chat model or LLM is malformed, the can throw an `OutputParserException` to indicate that parsing fails because of bad input. Using this exception allows code that utilizes the parser to handle the exceptions in a consistent manner.\n",
     "\n",
-    ":::{.callout-tip} Parsers are Runnables! 🏃\n",
+    ":::tip Parsers are Runnables! 🏃\n",
     "\n",
     "Because `BaseOutputParser` implements the `Runnable` interface, any custom parser you will create this way will become valid LangChain Runnables and will benefit from automatic async support, batch interface, logging support etc.\n",
     ":::\n"
@@ -458,7 +458,7 @@
    "id": "18f83192-37e8-43f5-ab29-9568b1279f1b",
    "metadata": {},
    "source": [
-    ":::{.callout-note}\n",
+    ":::note\n",
     "The parser will work with either the output from an LLM (a string) or the output from a chat model (an `AIMessage`)!\n",
     ":::"
    ]

docs/docs/how_to/output_parser_json.ipynb

@@ -20,7 +20,7 @@
     "\n",
     "While some model providers support [built-in ways to return structured output](/docs/how_to/structured_output), not all do. We can use an output parser to help users to specify an arbitrary JSON schema via the prompt, query a model for outputs that conform to that schema, and finally parse that schema as JSON.\n",
     "\n",
-    ":::{.callout-note}\n",
+    ":::note\n",
     "Keep in mind that large language models are leaky abstractions! You'll have to use an LLM with sufficient capacity to generate well-formed JSON.\n",
     ":::"
    ]

docs/docs/how_to/output_parser_xml.ipynb

@@ -22,7 +22,7 @@
     "\n",
     "This guide shows you how to use the [`XMLOutputParser`](https://python.langchain.com/api_reference/core/output_parsers/langchain_core.output_parsers.xml.XMLOutputParser.html) to prompt models for XML output, then and parse that output into a usable format.\n",
     "\n",
-    ":::{.callout-note}\n",
+    ":::note\n",
     "Keep in mind that large language models are leaky abstractions! You'll have to use an LLM with sufficient capacity to generate well-formed XML.\n",
     ":::\n",
     "\n",

docs/docs/how_to/output_parser_yaml.ipynb

@@ -22,7 +22,7 @@
     "\n",
     "This output parser allows users to specify an arbitrary schema and query LLMs for outputs that conform to that schema, using YAML to format their response.\n",
     "\n",
-    ":::{.callout-note}\n",
+    ":::note\n",
     "Keep in mind that large language models are leaky abstractions! You'll have to use an LLM with sufficient capacity to generate well-formed YAML.\n",
     ":::\n"
    ]

docs/docs/how_to/parallel.ipynb

@@ -118,7 +118,7 @@
    "id": "392cd4c4-e7ed-4ab8-934d-f7a4eca55ee1",
    "metadata": {},
    "source": [
-    "::: {.callout-tip}\n",
+    ":::tip\n",
     "Note that when composing a RunnableParallel with another Runnable we don't even need to wrap our dictionary in the RunnableParallel class — the type conversion is handled for us. In the context of a chain, these are equivalent:\n",
     ":::\n",
     "\n",

docs/docs/how_to/qa_chat_history_how_to.ipynb

@@ -120,11 +120,9 @@
    "id": "646840fb-5212-48ea-8bc7-ec7be5ec727e",
    "metadata": {},
    "source": [
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
-    "<ChatModelTabs customVarName=\"llm\" />\n",
-    "```"
+    "<ChatModelTabs customVarName=\"llm\" />\n"
    ]
   },
   {

docs/docs/how_to/qa_citations.ipynb

@@ -67,11 +67,9 @@
    "source": [
     "Let's first select a LLM:\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
-    "<ChatModelTabs customVarName=\"llm\" />\n",
-    "```"
+    "<ChatModelTabs customVarName=\"llm\" />\n"
    ]
   },
   {

docs/docs/how_to/qa_per_user.ipynb

@@ -124,11 +124,10 @@
     "We can now create the chain that we will use to do question-answering over.\n",
     "\n",
     "Let's first select a LLM.\n",
-    "```{=mdx}\n",
+    "\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
-    "<ChatModelTabs customVarName=\"llm\" />\n",
-    "```"
+    "<ChatModelTabs customVarName=\"llm\" />\n"
    ]
   },
   {

docs/docs/how_to/qa_sources.ipynb

@@ -100,11 +100,9 @@
     "\n",
     "Let's first select a LLM:\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
-    "<ChatModelTabs customVarName=\"llm\" />\n",
-    "```"
+    "<ChatModelTabs customVarName=\"llm\" />\n"
    ]
   },
   {
@@ -312,7 +310,7 @@
    "id": "b437da5d-ca09-4d15-9be2-c35e5a1ace77",
    "metadata": {},
    "source": [
-    ":::{.callout-tip}\n",
+    ":::tip\n",
     "\n",
     "Check out the [LangSmith trace](https://smith.langchain.com/public/1c055a3b-0236-4670-a3fb-023d418ba796/r)\n",
     "\n",
@@ -410,7 +408,7 @@
    "id": "7440f785-29c5-4c6b-9656-0d9d5efbac05",
    "metadata": {},
    "source": [
-    ":::{.callout-tip}\n",
+    ":::tip\n",
     "\n",
     "View [LangSmith trace](https://smith.langchain.com/public/0eeddf06-3a7b-4f27-974c-310ca8160f60/r)\n",
     "\n",

docs/docs/how_to/qa_streaming.ipynb

@@ -93,11 +93,9 @@
     "\n",
     "Let's first select a LLM:\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
-    "<ChatModelTabs customVarName=\"llm\" />\n",
-    "```"
+    "<ChatModelTabs customVarName=\"llm\" />\n"
    ]
   },
   {

docs/docs/how_to/sequence.ipynb

@@ -37,13 +37,11 @@
     "\n",
     "To show off how this works, let's go through an example. We'll walk through a common pattern in LangChain: using a [prompt template](/docs/how_to#prompt-templates) to format input into a [chat model](/docs/how_to#chat-models), and finally converting the chat message output into a string with an [output parser](/docs/how_to#output-parsers).\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
     "<ChatModelTabs\n",
     "  customVarName=\"model\"\n",
-    "/>\n",
-    "```"
+    "/>\n"
    ]
   },
   {

docs/docs/how_to/serialization.ipynb

@@ -18,7 +18,7 @@
     "\n",
     "Below we walk through an example with a simple [LLM chain](/docs/tutorials/llm_chain).\n",
     "\n",
-    ":::{.callout-caution}\n",
+    ":::caution\n",
     "\n",
     "De-serialization using `load` and `loads` can instantiate any serializable LangChain object. Only use this feature with trusted inputs!\n",
     "\n",

docs/docs/how_to/split_by_token.ipynb

@@ -17,7 +17,7 @@
    "source": [
     "## tiktoken\n",
     "\n",
-    ":::{.callout-note}\n",
+    ":::note\n",
     "[tiktoken](https://github.com/openai/tiktoken) is a fast `BPE` tokenizer created by `OpenAI`.\n",
     ":::\n",
     "\n",
@@ -171,7 +171,7 @@
    "source": [
     "## spaCy\n",
     "\n",
-    ":::{.callout-note}\n",
+    ":::note\n",
     "[spaCy](https://spacy.io/) is an open-source software library for advanced natural language processing, written in the programming languages Python and Cython.\n",
     ":::\n",
     "\n",
@@ -363,7 +363,7 @@
    "source": [
     "## NLTK\n",
     "\n",
-    ":::{.callout-note}\n",
+    ":::note\n",
     "[The Natural Language Toolkit](https://en.wikipedia.org/wiki/Natural_Language_Toolkit), or more commonly [NLTK](https://www.nltk.org/), is a suite of libraries and programs for symbolic and statistical natural language processing (NLP) for English written in the Python programming language.\n",
     ":::\n",
     "\n",
@@ -466,7 +466,7 @@
    "source": [
     "## KoNLPY\n",
     "\n",
-    ":::{.callout-note}\n",
+    ":::note\n",
     "[KoNLPy: Korean NLP in Python](https://konlpy.org/en/latest/) is is a Python package for natural language processing (NLP) of the Korean language.\n",
     ":::\n",
     "\n",

docs/docs/how_to/sql_csv.ipynb

@@ -167,11 +167,9 @@
    "source": [
     "And create a [SQL agent](/docs/tutorials/sql_qa) to interact with it:\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
-    "<ChatModelTabs customVarName=\"llm\" />\n",
-    "```"
+    "<ChatModelTabs customVarName=\"llm\" />\n"
    ]
   },
   {

docs/docs/how_to/sql_large_db.ipynb

@@ -94,11 +94,9 @@
     "\n",
     "One easy and reliable way to do this is using [tool-calling](/docs/how_to/tool_calling). Below, we show how we can use this feature to obtain output conforming to a desired format (in this case, a list of table names). We use the chat model's `.bind_tools` method to bind a tool in Pydantic format, and feed this into an output parser to reconstruct the object from the model's response.\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
-    "<ChatModelTabs customVarName=\"llm\" />\n",
-    "```"
+    "<ChatModelTabs customVarName=\"llm\" />\n"
    ]
   },
   {

docs/docs/how_to/sql_prompting.ipynb

@@ -125,11 +125,9 @@
    "source": [
     "For example, using our current DB we can see that we'll get a SQLite-specific prompt.\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
-    "<ChatModelTabs customVarName=\"llm\" />\n",
-    "```"
+    "<ChatModelTabs customVarName=\"llm\" />\n"
    ]
   },
   {

docs/docs/how_to/sql_query_checking.ipynb

@@ -91,11 +91,9 @@
     "\n",
     "Perhaps the simplest strategy is to ask the model itself to check the original query for common mistakes. Suppose we have the following SQL query chain:\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
-    "<ChatModelTabs customVarName=\"llm\" />\n",
-    "```"
+    "<ChatModelTabs customVarName=\"llm\" />\n"
    ]
   },
   {

docs/docs/how_to/streaming.ipynb

@@ -67,13 +67,11 @@
     "\n",
     "We will show examples of streaming using a chat model. Choose one from the options below:\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
     "<ChatModelTabs\n",
     "  customVarName=\"model\"\n",
-    "/>\n",
-    "```"
+    "/>\n"
    ]
   },
   {
@@ -248,7 +246,7 @@
     "\n",
     "We will use [`StrOutputParser`](https://python.langchain.com/api_reference/core/output_parsers/langchain_core.output_parsers.string.StrOutputParser.html) to parse the output from the model. This is a simple parser that extracts the `content` field from an `AIMessageChunk`, giving us the `token` returned by the model.\n",
     "\n",
-    ":::{.callout-tip}\n",
+    ":::tip\n",
     "LCEL is a *declarative* way to specify a \"program\" by chainining together different LangChain primitives. Chains created using LCEL benefit from an automatic implementation of `stream` and `astream` allowing streaming of the final output. In fact, chains created with LCEL implement the entire standard Runnable interface.\n",
     ":::"
    ]
@@ -306,7 +304,7 @@
    "id": "1b399fb4-5e3c-4581-9570-6df9b42b623d",
    "metadata": {},
    "source": [
-    ":::{.callout-note}\n",
+    ":::note\n",
     "The LangChain Expression language allows you to separate the construction of a chain from the mode in which it is used (e.g., sync/async, batch/streaming etc.). If this is not relevant to what you're building, you can also rely on a standard **imperative** programming approach by\n",
     "caling `invoke`, `batch` or `stream` on each component individually, assigning the results to variables and then using them downstream as you see fit.\n",
     "\n",
@@ -385,11 +383,11 @@
    "source": [
     "Now, let's **break** streaming. We'll use the previous example and append an extraction function at the end that extracts the country names from the finalized JSON.\n",
     "\n",
-    ":::{.callout-warning}\n",
+    ":::warning\n",
     "Any steps in the chain that operate on **finalized inputs** rather than on **input streams** can break streaming functionality via `stream` or `astream`.\n",
     ":::\n",
     "\n",
-    ":::{.callout-tip}\n",
+    ":::tip\n",
     "Later, we will discuss the `astream_events` API which streams results from intermediate steps. This API will stream results from intermediate steps even if the chain contains steps that only operate on **finalized inputs**.\n",
     ":::"
    ]
@@ -454,7 +452,7 @@
     "\n",
     "Let's fix the streaming using a generator function that can operate on the **input stream**.\n",
     "\n",
-    ":::{.callout-tip}\n",
+    ":::tip\n",
     "A generator function (a function that uses `yield`) allows writing code that operates on **input streams**\n",
     ":::"
    ]
@@ -517,7 +515,7 @@
    "id": "d59823f5-9b9a-43c5-a213-34644e2f1d3d",
    "metadata": {},
    "source": [
-    ":::{.callout-note}\n",
+    ":::note\n",
     "Because the code above is relying on JSON auto-completion, you may see partial names of countries (e.g., `Sp` and `Spain`), which is not what one would want for an extraction result!\n",
     "\n",
     "We're focusing on streaming concepts, not necessarily the results of the chains.\n",
@@ -585,7 +583,7 @@
     "\n",
     "This is OK 🥹! Not all components have to implement streaming -- in some cases streaming is either unnecessary, difficult or just doesn't make sense.\n",
     "\n",
-    ":::{.callout-tip}\n",
+    ":::tip\n",
     "An LCEL chain constructed using non-streaming components, will still be able to stream in a lot of cases, with streaming of partial output starting after the last non-streaming step in the chain.\n",
     ":::"
    ]
@@ -654,7 +652,7 @@
     "\n",
     "Event Streaming is a **beta** API. This API may change a bit based on feedback.\n",
     "\n",
-    ":::{.callout-note}\n",
+    ":::note\n",
     "\n",
     "This guide demonstrates the `V2` API and requires langchain-core >= 0.2. For the `V1` API compatible with older versions of LangChain, see [here](https://python.langchain.com/v0.1/docs/expression_language/streaming/#using-stream-events).\n",
     ":::"
@@ -689,27 +687,27 @@
     "Below is a reference table that shows some events that might be emitted by the various Runnable objects.\n",
     "\n",
     "\n",
-    ":::{.callout-note}\n",
+    ":::note\n",
     "When streaming is implemented properly, the inputs to a runnable will not be known until after the input stream has been entirely consumed. This means that `inputs` will often be included only for `end` events and rather than for `start` events.\n",
     ":::\n",
     "\n",
     "| event                | name             | chunk                           | input                                         | output                                          |\n",
     "|----------------------|------------------|---------------------------------|-----------------------------------------------|-------------------------------------------------|\n",
-    "| on_chat_model_start  | [model name]     |                                 | {\"messages\": [[SystemMessage, HumanMessage]]} |                                                 |\n",
+    "| on_chat_model_start  | [model name]     |                                 | \\{\"messages\": [[SystemMessage, HumanMessage]]\\} |                                                 |\n",
     "| on_chat_model_stream | [model name]     | AIMessageChunk(content=\"hello\") |                                               |                                                 |\n",
-    "| on_chat_model_end    | [model name]     |                                 | {\"messages\": [[SystemMessage, HumanMessage]]} | AIMessageChunk(content=\"hello world\")           |\n",
-    "| on_llm_start         | [model name]     |                                 | {'input': 'hello'}                            |                                                 |\n",
+    "| on_chat_model_end    | [model name]     |                                 | \\{\"messages\": [[SystemMessage, HumanMessage]]\\} | AIMessageChunk(content=\"hello world\")           |\n",
+    "| on_llm_start         | [model name]     |                                 | \\{'input': 'hello'\\}                            |                                                 |\n",
     "| on_llm_stream        | [model name]     | 'Hello'                         |                                               |                                                 |\n",
     "| on_llm_end           | [model name]     |                                 | 'Hello human!'                                |                                                 |\n",
     "| on_chain_start       | format_docs      |                                 |                                               |                                                 |\n",
     "| on_chain_stream      | format_docs      | \"hello world!, goodbye world!\"  |                                               |                                                 |\n",
     "| on_chain_end         | format_docs      |                                 | [Document(...)]                               | \"hello world!, goodbye world!\"                  |\n",
-    "| on_tool_start        | some_tool        |                                 | {\"x\": 1, \"y\": \"2\"}                            |                                                 |\n",
-    "| on_tool_end          | some_tool        |                                 |                                               | {\"x\": 1, \"y\": \"2\"}                              |\n",
-    "| on_retriever_start   | [retriever name] |                                 | {\"query\": \"hello\"}                            |                                                 |\n",
-    "| on_retriever_end     | [retriever name] |                                 | {\"query\": \"hello\"}                            | [Document(...), ..]                             |\n",
-    "| on_prompt_start      | [template_name]  |                                 | {\"question\": \"hello\"}                         |                                                 |\n",
-    "| on_prompt_end        | [template_name]  |                                 | {\"question\": \"hello\"}                         | ChatPromptValue(messages: [SystemMessage, ...]) |"
+    "| on_tool_start        | some_tool        |                                 | \\{\"x\": 1, \"y\": \"2\"\\}                            |                                                 |\n",
+    "| on_tool_end          | some_tool        |                                 |                                               | \\{\"x\": 1, \"y\": \"2\"\\}                              |\n",
+    "| on_retriever_start   | [retriever name] |                                 | \\{\"query\": \"hello\"\\}                            |                                                 |\n",
+    "| on_retriever_end     | [retriever name] |                                 | \\{\"query\": \"hello\"\\}                            | [Document(...), ..]                             |\n",
+    "| on_prompt_start      | [template_name]  |                                 | \\{\"question\": \"hello\"\\}                         |                                                 |\n",
+    "| on_prompt_end        | [template_name]  |                                 | \\{\"question\": \"hello\"\\}                         | ChatPromptValue(messages: [SystemMessage, ...]) |"
    ]
   },
   {
@@ -748,7 +746,7 @@
    "id": "32972939-2995-4b2e-84db-045adb044fad",
    "metadata": {},
    "source": [
-    ":::{.callout-note}\n",
+    ":::note\n",
     "\n",
     "Hey what's that funny version=\"v2\" parameter in the API?! 😾\n",
     "\n",
@@ -1129,7 +1127,7 @@
    "source": [
     "#### By Tags\n",
     "\n",
-    ":::{.callout-caution}\n",
+    ":::caution\n",
     "\n",
     "Tags are inherited by child components of a given runnable. \n",
     "\n",
@@ -1336,11 +1334,11 @@
    "source": [
     "### Propagating Callbacks\n",
     "\n",
-    ":::{.callout-caution}\n",
+    ":::caution\n",
     "If you're using invoking runnables inside your tools, you need to propagate callbacks to the runnable; otherwise, no stream events will be generated.\n",
     ":::\n",
     "\n",
-    ":::{.callout-note}\n",
+    ":::note\n",
     "When using `RunnableLambdas` or `@chain` decorator, callbacks are propagated automatically behind the scenes.\n",
     ":::"
    ]

docs/docs/how_to/streaming_llm.ipynb

@@ -17,7 +17,7 @@
     "\n",
     "\n",
     "\n",
-    ":::{.callout-note}\n",
+    ":::note\n",
     "\n",
     "The **default** implementation does **not** provide support for token-by-token streaming, but it ensures that the model can be swapped in for any other model as it supports the same standard interface.\n",
     "\n",
@@ -114,7 +114,7 @@
     "\n",
     "LLMs also support the standard [astream events](https://python.langchain.com/api_reference/core/runnables/langchain_core.runnables.base.Runnable.html#langchain_core.runnables.base.Runnable.astream_events) method.\n",
     "\n",
-    ":::{.callout-tip}\n",
+    ":::tip\n",
     "\n",
     "`astream_events` is most useful when implementing streaming in a larger LLM application that contains multiple steps (e.g., an application that involves an `agent`).\n",
     ":::"

docs/docs/how_to/structured_output.ipynb

@@ -47,13 +47,11 @@
     "\n",
     "As an example, let's get a model to generate a joke and separate the setup from the punchline:\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
     "<ChatModelTabs\n",
     "  customVarName=\"llm\"\n",
-    "/>\n",
-    "```"
+    "/>\n"
    ]
   },
   {

docs/docs/how_to/summarize_map_reduce.ipynb

@@ -1,7 +1,7 @@
 {
  "cells": [
   {
-   "cell_type": "markdown",
+   "cell_type": "raw",
    "id": "c47f5b2f-e14c-43e7-a0ab-d71562636624",
    "metadata": {},
    "source": [
@@ -41,13 +41,12 @@
     "## Load chat model\n",
     "\n",
     "Let's first load a chat model:\n",
-    "```{=mdx}\n",
+    "\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
     "<ChatModelTabs\n",
     "  customVarName=\"llm\"\n",
-    "/>\n",
-    "```"
+    "/>\n"
    ]
   },
   {

docs/docs/how_to/summarize_refine.ipynb

@@ -46,13 +46,12 @@
     "## Load chat model\n",
     "\n",
     "Let's first load a chat model:\n",
-    "```{=mdx}\n",
+    "\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
     "<ChatModelTabs\n",
     "  customVarName=\"llm\"\n",
-    "/>\n",
-    "```"
+    "/>\n"
    ]
   },
   {

docs/docs/how_to/summarize_stuff.ipynb

@@ -31,13 +31,12 @@
     "## Load chat model\n",
     "\n",
     "Let's first load a chat model:\n",
-    "```{=mdx}\n",
+    "\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
     "<ChatModelTabs\n",
     "  customVarName=\"llm\"\n",
-    "/>\n",
-    "```"
+    "/>\n"
    ]
   },
   {

docs/docs/how_to/tool_artifacts.ipynb

@@ -145,13 +145,11 @@
     "\n",
     "With a [tool-calling model](/docs/how_to/tool_calling/), we can easily use a model to call our Tool and generate ToolMessages:\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
     "<ChatModelTabs\n",
     "  customVarName=\"llm\"\n",
-    "/>\n",
-    "```"
+    "/>\n"
    ]
   },
   {

docs/docs/how_to/tool_calling.ipynb

@@ -196,14 +196,12 @@
     "To actually bind those schemas to a chat model, we'll use the `.bind_tools()` method. This handles converting\n",
     "the `add` and `multiply` schemas to the proper format for the model. The tool schema will then be passed it in each time the model is invoked.\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
     "<ChatModelTabs\n",
     "  customVarName=\"llm\"\n",
     "  fireworksParams={`model=\"accounts/fireworks/models/firefunction-v1\", temperature=0`}\n",
-    "/>\n",
-    "```"
+    "/>\n"
    ]
   },
   {

docs/docs/how_to/tool_results_pass_to_model.ipynb

@@ -29,14 +29,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
     "<ChatModelTabs\n",
     "  customVarName=\"llm\"\n",
     "  fireworksParams={`model=\"accounts/fireworks/models/firefunction-v1\", temperature=0`}\n",
-    "/>\n",
-    "```"
+    "/>\n"
    ]
   },
   {

docs/docs/how_to/tool_runtime.ipynb

@@ -42,14 +42,12 @@
    "source": [
     "We can bind them to chat models as follows:\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
     "<ChatModelTabs\n",
     "  customVarName=\"llm\"\n",
     "  fireworksParams={`model=\"accounts/fireworks/models/firefunction-v1\", temperature=0`}\n",
-    "/>\n",
-    "```"
+    "/>\n"
    ]
   },
   {

docs/docs/how_to/tool_stream_events.ipynb

@@ -20,9 +20,9 @@
     "\n",
     ":::caution Compatibility\n",
     "\n",
-    "LangChain cannot automatically propagate configuration, including callbacks necessary for `astream_events()`, to child runnables if you are running `async` code in `python<=3.10`. This is a common reason why you may fail to see events being emitted from custom runnables or tools.\n",
+    "LangChain cannot automatically propagate configuration, including callbacks necessary for `astream_events()`, to child runnables if you are running `async` code in `python&lt;=3.10`. This is a common reason why you may fail to see events being emitted from custom runnables or tools.\n",
     "\n",
-    "If you are running python<=3.10, you will need to manually propagate the `RunnableConfig` object to the child runnable in async environments. For an example of how to manually propagate the config, see the implementation of the `bar` RunnableLambda below.\n",
+    "If you are running python&lt;=3.10, you will need to manually propagate the `RunnableConfig` object to the child runnable in async environments. For an example of how to manually propagate the config, see the implementation of the `bar` RunnableLambda below.\n",
     "\n",
     "If you are running python>=3.11, the `RunnableConfig` will automatically propagate to child runnables in async environment. However, it is still a good idea to propagate the `RunnableConfig` manually if your code may run in older Python versions.\n",
     "\n",
@@ -31,11 +31,9 @@
     "\n",
     "Say you have a custom tool that calls a chain that condenses its input by prompting a chat model to return only 10 words, then reversing the output. First, define it in a naive way:\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
-    "<ChatModelTabs customVarName=\"model\" />\n",
-    "```"
+    "<ChatModelTabs customVarName=\"model\" />\n"
    ]
   },
   {

docs/docs/how_to/tools_builtin.ipynb

@@ -32,7 +32,7 @@
     "\n",
     "LangChain has a large collection of 3rd party tools. Please visit [Tool Integrations](/docs/integrations/tools/) for a list of the available tools.\n",
     "\n",
-    ":::{.callout-important}\n",
+    ":::important\n",
     "\n",
     "When using 3rd party tools, make sure that you understand how the tool works, what permissions\n",
     "it has. Read over its documentation and check if anything is required from you\n",

docs/docs/how_to/tools_chain.ipynb

@@ -147,11 +147,9 @@
     "\n",
     "First we'll define our model and tools. We'll start with just a single tool, `multiply`.\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
-    "<ChatModelTabs customVarName=\"llm\"/>\n",
-    "```"
+    "<ChatModelTabs customVarName=\"llm\"/>\n"
    ]
   },
   {

docs/docs/how_to/tools_error.ipynb

@@ -79,11 +79,9 @@
     "\n",
     "Suppose we have the following (dummy) tool and tool-calling chain. We'll make our tool intentionally convoluted to try and trip up the model.\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
-    "<ChatModelTabs customVarName=\"llm\"/>\n",
-    "```"
+    "<ChatModelTabs customVarName=\"llm\"/>\n"
    ]
   },
   {

docs/docs/how_to/tools_human.ipynb

@@ -9,7 +9,7 @@
     "\n",
     "There are certain tools that we don't trust a model to execute on its own. One thing we can do in such situations is require human approval before the tool is invoked.\n",
     "\n",
-    ":::{.callout-info}\n",
+    ":::info\n",
     "\n",
     "This how-to guide shows a simple way to add human-in-the-loop for code running in a jupyter notebook or in a terminal.\n",
     "\n",
@@ -77,11 +77,9 @@
    "id": "43721981-4595-4721-bea0-5c67696426d3",
    "metadata": {},
    "source": [
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
-    "<ChatModelTabs customVarName=\"llm\"/>\n",
-    "```"
+    "<ChatModelTabs customVarName=\"llm\"/>\n"
    ]
   },
   {

docs/docs/how_to/tools_prompting.ipynb

@@ -17,7 +17,7 @@
    "source": [
     "# How to add ad-hoc tool calling capability to LLMs and Chat Models\n",
     "\n",
-    ":::{.callout-caution}\n",
+    ":::caution\n",
     "\n",
     "Some models have been fine-tuned for tool calling and provide a dedicated API for tool calling. Generally, such models are better at tool calling than non-fine-tuned models, and are recommended for use cases that require tool calling. Please see the [how to use a chat model to call tools](/docs/how_to/tool_calling) guide for more information.\n",
     "\n",
@@ -89,11 +89,9 @@
    "source": [
     "You can select any of the given models for this how-to guide. Keep in mind that most of these models already [support native tool calling](/docs/integrations/chat/), so using the prompting strategy shown here doesn't make sense for these models, and instead you should follow the [how to use a chat model to call tools](/docs/how_to/tool_calling) guide.\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
     "<ChatModelTabs openaiParams={`model=\"gpt-4\"`} />\n",
-    "```\n",
     "\n",
     "To illustrate the idea, we'll use `phi3` via Ollama, which does **NOT** have native support for tool calling. If you'd like to use `Ollama` as well follow [these instructions](/docs/integrations/chat/ollama/)."
    ]
@@ -318,7 +316,7 @@
    "id": "e1f08255-f146-4f4a-be43-5c21c1d3ae83",
    "metadata": {},
    "source": [
-    ":::{.callout-important}\n",
+    ":::important\n",
     "\n",
     "🎉 Amazing! 🎉 We now instructed our model on how to **request** that a tool be invoked.\n",
     "\n",

docs/docs/how_to/vectorstores.mdx

@@ -116,9 +116,7 @@ docs = db.similarity_search(query)
 print(docs[0].page_content)
 ```
 
-<CodeOutputBlock lang="python">
-
-```
+```output
     Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections.
 
     Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service.
@@ -128,7 +126,6 @@ print(docs[0].page_content)
     And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.
 ```
 
-</CodeOutputBlock>
 
 ### Similarity search by vector
 
@@ -140,9 +137,7 @@ docs = db.similarity_search_by_vector(embedding_vector)
 print(docs[0].page_content)
 ```
 
-<CodeOutputBlock lang="python">
-
-```
+```output
     Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections.
 
     Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service.
@@ -152,7 +147,6 @@ print(docs[0].page_content)
     And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.
 ```
 
-</CodeOutputBlock>
 
 ## Async Operations
 
@@ -166,13 +160,9 @@ docs = await db.asimilarity_search(query)
 docs
 ```
 
-<CodeOutputBlock lang="python">
-
-```
+```output
 [Document(page_content='Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. \n\nTonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. \n\nOne of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. \n\nAnd I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.', metadata={'source': 'state_of_the_union.txt'}),
  Document(page_content='A former top litigator in private practice. A former federal public defender. And from a family of public school educators and police officers. A consensus builder. Since she’s been nominated, she’s received a broad range of support—from the Fraternal Order of Police to former judges appointed by Democrats and Republicans. \n\nAnd if we are to advance liberty and justice, we need to secure the Border and fix the immigration system. \n\nWe can do both. At our border, we’ve installed new technology like cutting-edge scanners to better detect drug smuggling.  \n\nWe’ve set up joint patrols with Mexico and Guatemala to catch more human traffickers.  \n\nWe’re putting in place dedicated immigration judges so families fleeing persecution and violence can have their cases heard faster. \n\nWe’re securing commitments and supporting partners in South and Central America to host more refugees and secure their own borders.', metadata={'source': 'state_of_the_union.txt'}),
  Document(page_content='And for our LGBTQ+ Americans, let’s finally get the bipartisan Equality Act to my desk. The onslaught of state laws targeting transgender Americans and their families is wrong. \n\nAs I said last year, especially to our younger transgender Americans, I will always have your back as your President, so you can be yourself and reach your God-given potential. \n\nWhile it often appears that we never agree, that isn’t true. I signed 80 bipartisan bills into law last year. From preventing government shutdowns to protecting Asian-Americans from still-too-common hate crimes to reforming military justice. \n\nAnd soon, we’ll strengthen the Violence Against Women Act that I first wrote three decades ago. It is important for us to show the nation that we can come together and do big things. \n\nSo tonight I’m offering a Unity Agenda for the Nation. Four big things we can do together.  \n\nFirst, beat the opioid epidemic.', metadata={'source': 'state_of_the_union.txt'}),
  Document(page_content='Tonight, I’m announcing a crackdown on these companies overcharging American businesses and consumers. \n\nAnd as Wall Street firms take over more nursing homes, quality in those homes has gone down and costs have gone up.  \n\nThat ends on my watch. \n\nMedicare is going to set higher standards for nursing homes and make sure your loved ones get the care they deserve and expect. \n\nWe’ll also cut costs and keep the economy going strong by giving workers a fair shot, provide more training and apprenticeships, hire them based on their skills not degrees. \n\nLet’s pass the Paycheck Fairness Act and paid leave.  \n\nRaise the minimum wage to $15 an hour and extend the Child Tax Credit, so no one has to raise a family in poverty. \n\nLet’s increase Pell Grants and increase our historic support of HBCUs, and invest in what Jill—our First Lady who teaches full-time—calls America’s best-kept secret: community colleges.', metadata={'source': 'state_of_the_union.txt'})]
 ```
-
-</CodeOutputBlock>

docs/docs/integrations/chat/anthropic_functions.ipynb

@@ -17,7 +17,7 @@
    "source": [
     "# [Deprecated] Experimental Anthropic Tools Wrapper\n",
     "\n",
-    "::: {.callout-warning}\n",
+    ":::warning\n",
     "\n",
     "The Anthropic API officially supports tool-calling so this workaround is no longer needed. Please use [ChatAnthropic](/docs/integrations/chat/anthropic) with `langchain-anthropic>=0.1.15`.\n",
     "\n",
@@ -118,7 +118,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": ".venv",
    "language": "python",
    "name": "python3"
   },
@@ -132,7 +132,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.1"
+   "version": "3.11.4"
   }
  },
  "nbformat": 4,

docs/docs/integrations/chat/sambanova.ipynb

@@ -0,0 +1,374 @@
+{
+ "cells": [
+  {
+   "cell_type": "raw",
+   "metadata": {
+    "vscode": {
+     "languageId": "raw"
+    }
+   },
+   "source": [
+    "---\n",
+    "sidebar_label: SambaNovaCloud\n",
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# ChatSambaNovaCloud\n",
+    "\n",
+    "This will help you getting started with SambaNovaCloud [chat models](/docs/concepts/#chat-models). For detailed documentation of all ChatSambaNovaCloud features and configurations head to the [API reference](https://api.python.langchain.com/en/latest/chat_models/langchain_community.chat_models.sambanova.ChatSambaNovaCloud.html).\n",
+    "\n",
+    "**[SambaNova](https://sambanova.ai/)'s** [SambaNova Cloud](https://cloud.sambanova.ai/) is a platform for performing inference with open-source models\n",
+    "\n",
+    "## Overview\n",
+    "### Integration details\n",
+    "\n",
+    "| Class | Package | Local | Serializable | JS support | Package downloads | Package latest |\n",
+    "| :--- | :--- | :---: | :---: |  :---: | :---: | :---: |\n",
+    "| [ChatSambaNovaCloud](https://api.python.langchain.com/en/latest/chat_models/langchain_community.chat_models.sambanova.ChatSambaNovaCloud.html) | [langchain-community](https://python.langchain.com/v0.2/api_reference/community/index.html) | ❌ | ❌ | ❌ | ![PyPI - Downloads](https://img.shields.io/pypi/dm/langchain_community?style=flat-square&label=%20) | ![PyPI - Version](https://img.shields.io/pypi/v/langchain_community?style=flat-square&label=%20) |\n",
+    "\n",
+    "### Model features\n",
+    "\n",
+    "| [Tool calling](/docs/how_to/tool_calling) | [Structured output](/docs/how_to/structured_output/) | JSON mode | [Image input](/docs/how_to/multimodal_inputs/) | Audio input | Video input | [Token-level streaming](/docs/how_to/chat_streaming/) | Native async | [Token usage](/docs/how_to/chat_token_usage_tracking/) | [Logprobs](/docs/how_to/logprobs/) |\n",
+    "| :---: | :---: | :---: | :---: |  :---: | :---: | :---: | :---: | :---: | :---: |\n",
+    "| ❌ | ❌ | ❌ | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ | ❌ | \n",
+    "\n",
+    "## Setup\n",
+    "\n",
+    "To access ChatSambaNovaCloud models you will need to create a [SambaNovaCloud](https://cloud.sambanova.ai/) account, get an API key, install the `langchain_community` integration package, and install the `SSEClient` Package.\n",
+    "\n",
+    "```bash\n",
+    "pip install langchain-community\n",
+    "pip install sseclient-py\n",
+    "```\n",
+    "\n",
+    "### Credentials\n",
+    "\n",
+    "Get an API Key from [cloud.sambanova.ai](https://cloud.sambanova.ai/apis) and add it to your environment variables:\n",
+    "\n",
+    "``` bash\n",
+    "export SAMBANOVA_API_KEY=\"your-api-key-here\"\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import getpass\n",
+    "import os\n",
+    "\n",
+    "if not os.getenv(\"SAMBANOVA_API_KEY\"):\n",
+    "    os.environ[\"SAMBANOVA_API_KEY\"] = getpass.getpass(\n",
+    "        \"Enter your SambaNova Cloud API key: \"\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If you want to get automated tracing of your model calls you can also set your [LangSmith](https://docs.smith.langchain.com/) API key by uncommenting below:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# os.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\n",
+    "# os.environ[\"LANGCHAIN_API_KEY\"] = getpass.getpass(\"Enter your LangSmith API key: \")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Installation\n",
+    "\n",
+    "The LangChain __SambaNovaCloud__ integration lives in the `langchain_community` package:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%pip install -qU langchain-community\n",
+    "%pip install -qu sseclient-py"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Instantiation\n",
+    "\n",
+    "Now we can instantiate our model object and generate chat completions:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_community.chat_models.sambanova import ChatSambaNovaCloud\n",
+    "\n",
+    "llm = ChatSambaNovaCloud(\n",
+    "    model=\"llama3-405b\", max_tokens=1024, temperature=0.7, top_k=1, top_p=0.01\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Invocation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=\"J'adore la programmation.\", response_metadata={'finish_reason': 'stop', 'usage': {'acceptance_rate': 11, 'completion_tokens': 9, 'completion_tokens_after_first_per_sec': 97.07042823956884, 'completion_tokens_after_first_per_sec_first_ten': 276.3343994441849, 'completion_tokens_per_sec': 23.775192800224037, 'end_time': 1726158364.7954874, 'is_last_response': True, 'prompt_tokens': 56, 'start_time': 1726158364.3670964, 'time_to_first_token': 0.3459765911102295, 'total_latency': 0.3785458261316473, 'total_tokens': 65, 'total_tokens_per_sec': 171.70972577939582}, 'model_name': 'Meta-Llama-3.1-405B-Instruct', 'system_fingerprint': 'fastcoe', 'created': 1726158364}, id='7154b676-9d5a-4b1a-a425-73bbe69f28fc')"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "messages = [\n",
+    "    (\n",
+    "        \"system\",\n",
+    "        \"You are a helpful assistant that translates English to French. Translate the user sentence.\",\n",
+    "    ),\n",
+    "    (\"human\", \"I love programming.\"),\n",
+    "]\n",
+    "ai_msg = llm.invoke(messages)\n",
+    "ai_msg"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "J'adore la programmation.\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(ai_msg.content)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Chaining\n",
+    "\n",
+    "We can [chain](/docs/how_to/sequence/) our model with a prompt template like so:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content='Ich liebe Programmieren.', response_metadata={'finish_reason': 'stop', 'usage': {'acceptance_rate': 11, 'completion_tokens': 6, 'completion_tokens_after_first_per_sec': 47.80258530102961, 'completion_tokens_after_first_per_sec_first_ten': 215.59002827036753, 'completion_tokens_per_sec': 5.263977583489829, 'end_time': 1726158506.3777263, 'is_last_response': True, 'prompt_tokens': 51, 'start_time': 1726158505.1611376, 'time_to_first_token': 1.1119918823242188, 'total_latency': 1.1398224830627441, 'total_tokens': 57, 'total_tokens_per_sec': 50.00778704315337}, 'model_name': 'Meta-Llama-3.1-405B-Instruct', 'system_fingerprint': 'fastcoe', 'created': 1726158505}, id='226471ac-8c52-44bb-baa7-f9d2f8c54477')"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain_core.prompts import ChatPromptTemplate\n",
+    "\n",
+    "prompt = ChatPromptTemplate(\n",
+    "    [\n",
+    "        (\n",
+    "            \"system\",\n",
+    "            \"You are a helpful assistant that translates {input_language} to {output_language}.\",\n",
+    "        ),\n",
+    "        (\"human\", \"{input}\"),\n",
+    "    ]\n",
+    ")\n",
+    "\n",
+    "chain = prompt | llm\n",
+    "chain.invoke(\n",
+    "    {\n",
+    "        \"input_language\": \"English\",\n",
+    "        \"output_language\": \"German\",\n",
+    "        \"input\": \"I love programming.\",\n",
+    "    }\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Streaming"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Yer lookin' fer some info on owls, eh? Alright then, matey, settle yerself down with a pint o' grog and listen close.\n",
+      "\n",
+      "Owls be nocturnal birds o' prey, meanin' they do most o' their huntin' at night. They got big, round eyes that be perfect fer seein' in the dark, like a trusty lantern on a dark sea. Their ears be sharp as a cutlass, too, helpin' 'em pinpoint the slightest sound o' a scurvy rodent scurryin' through the underbrush.\n",
+      "\n",
+      "These birds be known fer their silent flight, like a ghost ship sailin' through the night. Their feathers be special, with a soft, fringed edge that helps 'em sneak up on their prey. And when they strike, it be swift and deadly, like a pirate's sword.\n",
+      "\n",
+      "Owls be found all over the world, from the frozen tundras o' the north to the scorching deserts o' the south. They come in all shapes and sizes, from the tiny elf owl to the great grey owl, which be as big as a small dog.\n",
+      "\n",
+      "Now, I know what ye be thinkin', \"Pirate, what about their hootin'?\" Aye, owls be famous fer their hoots, which be a form o' communication. They use different hoots to warn off predators, attract a mate, or even just to say, \"Shiver me timbers, I be happy to be alive!\"\n",
+      "\n",
+      "So there ye have it, me hearty. Owls be fascinatin' creatures, and I hope ye found this info as interestin' as a chest overflowin' with gold doubloons. Fair winds and following seas!"
+     ]
+    }
+   ],
+   "source": [
+    "system = \"You are a helpful assistant with pirate accent.\"\n",
+    "human = \"I want to learn more about this animal: {animal}\"\n",
+    "prompt = ChatPromptTemplate.from_messages([(\"system\", system), (\"human\", human)])\n",
+    "\n",
+    "chain = prompt | llm\n",
+    "\n",
+    "for chunk in chain.stream({\"animal\": \"owl\"}):\n",
+    "    print(chunk.content, end=\"\", flush=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Async"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content='The capital of France is Paris.', response_metadata={'finish_reason': 'stop', 'usage': {'acceptance_rate': 13, 'completion_tokens': 8, 'completion_tokens_after_first_per_sec': 86.00726488715989, 'completion_tokens_after_first_per_sec_first_ten': 326.92555640828857, 'completion_tokens_per_sec': 21.74539360394493, 'end_time': 1726159287.9987085, 'is_last_response': True, 'prompt_tokens': 43, 'start_time': 1726159287.5738964, 'time_to_first_token': 0.34342360496520996, 'total_latency': 0.36789400760944074, 'total_tokens': 51, 'total_tokens_per_sec': 138.62688422514893}, 'model_name': 'Meta-Llama-3.1-405B-Instruct', 'system_fingerprint': 'fastcoe', 'created': 1726159287}, id='9b4ef015-50a2-434b-b980-29f8aa90c3e8')"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "prompt = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        (\n",
+    "            \"human\",\n",
+    "            \"what is the capital of {country}?\",\n",
+    "        )\n",
+    "    ]\n",
+    ")\n",
+    "\n",
+    "chain = prompt | llm\n",
+    "await chain.ainvoke({\"country\": \"France\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Async Streaming"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Quantum computers use quantum bits (qubits) to process vast amounts of data simultaneously, leveraging quantum mechanics to solve complex problems exponentially faster than classical computers."
+     ]
+    }
+   ],
+   "source": [
+    "prompt = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        (\n",
+    "            \"human\",\n",
+    "            \"in less than {num_words} words explain me {topic} \",\n",
+    "        )\n",
+    "    ]\n",
+    ")\n",
+    "chain = prompt | llm\n",
+    "\n",
+    "async for chunk in chain.astream({\"num_words\": 30, \"topic\": \"quantum computers\"}):\n",
+    "    print(chunk.content, end=\"\", flush=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## API reference\n",
+    "\n",
+    "For detailed documentation of all ChatSambaNovaCloud features and configurations head to the API reference: https://api.python.langchain.com/en/latest/chat_models/langchain_community.chat_models.sambanova.ChatSambaNovaCloud.html"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "langchain",
+   "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.9.19"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

docs/docs/integrations/document_loaders/blockchain.ipynb

@@ -44,7 +44,7 @@
     "The output takes the following format:\n",
     "\n",
     "- pageContent= Individual NFT\n",
-    "- metadata={'source': '0x1a92f7381b9f03921564a437210bb9396471050c', 'blockchain': 'eth-mainnet', 'tokenId': '0x15'})"
+    "- metadata=\\{'source': '0x1a92f7381b9f03921564a437210bb9396471050c', 'blockchain': 'eth-mainnet', 'tokenId': '0x15'\\}"
    ]
   },
   {

docs/docs/integrations/document_loaders/confluence.ipynb

@@ -19,7 +19,7 @@
     "\n",
     "You can also specify a boolean `include_attachments` to include attachments, this is set to False by default, if set to True all attachments will be downloaded and ConfluenceReader will extract the text from the attachments and add it to the Document object. Currently supported attachment types are: `PDF`, `PNG`, `JPEG/JPG`, `SVG`, `Word` and `Excel`.\n",
     "\n",
-    "Hint: `space_key` and `page_id` can both be found in the URL of a page in Confluence - https://yoursite.atlassian.com/wiki/spaces/<space_key>/pages/<page_id>\n"
+    "Hint: `space_key` and `page_id` can both be found in the URL of a page in Confluence - https://yoursite.atlassian.com/wiki/spaces/&lt;space_key&gt;/pages/&lt;page_id&gt;\n"
    ]
   },
   {

docs/docs/integrations/document_loaders/figma.ipynb

@@ -40,9 +40,9 @@
    "source": [
     "The Figma API Requires an access token, node_ids, and a file key.\n",
     "\n",
-    "The file key can be pulled from the URL.  https://www.figma.com/file/{filekey}/sampleFilename\n",
+    "The file key can be pulled from the URL.  https://www.figma.com/file/\\{filekey\\}/sampleFilename\n",
     "\n",
-    "Node IDs are also available in the URL. Click on anything and look for the '?node-id={node_id}' param.\n",
+    "Node IDs are also available in the URL. Click on anything and look for the '?node-id=\\{node_id\\}' param.\n",
     "\n",
     "Access token instructions are in the Figma help center article: https://help.figma.com/hc/en-us/articles/8085703771159-Manage-personal-access-tokens"
    ]

docs/docs/integrations/document_loaders/index.mdx

@@ -25,6 +25,8 @@ data = loader.load()
 
 The below document loaders allow you to load webpages.
 
+See this guide for a starting point: [How to: load web pages](/docs/how_to/document_loader_web).
+
 <CategoryTable category="webpage_loaders" />
 
 ## PDFs

docs/docs/integrations/document_loaders/mintbase.ipynb

@@ -44,7 +44,7 @@
     "The output takes the following format:\n",
     "\n",
     "- pageContent= Individual NFT\n",
-    "- metadata={'source': 'nft.yearofchef.near', 'blockchain': 'mainnet', 'tokenId': '1846'}"
+    "- metadata=\\{'source': 'nft.yearofchef.near', 'blockchain': 'mainnet', 'tokenId': '1846'\\}"
    ]
   },
   {

docs/docs/integrations/document_loaders/mongodb.ipynb

@@ -47,7 +47,7 @@
     "The output takes the following format:\n",
     "\n",
     "- pageContent= Mongo Document\n",
-    "- metadata={'database': '[database_name]', 'collection': '[collection_name]'}"
+    "- metadata=\\{'database': '[database_name]', 'collection': '[collection_name]'\\}"
    ]
   },
   {

docs/docs/integrations/document_loaders/pebblo.ipynb

@@ -124,6 +124,39 @@
   {
    "cell_type": "markdown",
    "metadata": {},
+   "source": [
+    "### Anonymize the snippets to redact all PII details\n",
+    "\n",
+    "Set `anonymize_snippets` to `True` to anonymize all personally identifiable information (PII) from the snippets going into VectorDB and the generated reports.\n",
+    "\n",
+    "> Note: The _Pebblo Entity Classifier_ effectively identifies personally identifiable information (PII) and is continuously evolving. While its recall is not yet 100%, it is steadily improving.\n",
+    "> For more details, please refer to the [_Pebblo Entity Classifier docs_](https://daxa-ai.github.io/pebblo/entityclassifier/)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_community.document_loaders import CSVLoader, PebbloSafeLoader\n",
+    "\n",
+    "loader = PebbloSafeLoader(\n",
+    "    CSVLoader(\"data/corp_sens_data.csv\"),\n",
+    "    name=\"acme-corp-rag-1\",  # App name (Mandatory)\n",
+    "    owner=\"Joe Smith\",  # Owner (Optional)\n",
+    "    description=\"Support productivity RAG application\",  # Description (Optional)\n",
+    "    anonymize_snippets=True,  # Whether to anonymize entities in the PDF Report (Optional, default=False)\n",
+    ")\n",
+    "documents = loader.load()\n",
+    "print(documents[0].metadata)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
    "source": []
   }
  ],

docs/docs/integrations/document_loaders/rspace.ipynb

@@ -32,7 +32,7 @@
    "source": [
     "It's best to store your RSpace API key as an environment variable. \n",
     "\n",
-    "    RSPACE_API_KEY=<YOUR_KEY>\n",
+    "    RSPACE_API_KEY=&lt;YOUR_KEY&gt;\n",
     "\n",
     "You'll also need to set the URL of your RSpace installation e.g.\n",
     "\n",

docs/docs/integrations/document_loaders/slack.ipynb

@@ -15,7 +15,7 @@
     "\n",
     "## 🧑 Instructions for ingesting your own dataset\n",
     "\n",
-    "Export your Slack data. You can do this by going to your Workspace Management page and clicking the Import/Export option ({your_slack_domain}.slack.com/services/export). Then, choose the right date range and click `Start export`. Slack will send you an email and a DM when the export is ready.\n",
+    "Export your Slack data. You can do this by going to your Workspace Management page and clicking the Import/Export option (\\{your_slack_domain\\}.slack.com/services/export). Then, choose the right date range and click `Start export`. Slack will send you an email and a DM when the export is ready.\n",
     "\n",
     "The download will produce a `.zip` file in your Downloads folder (or wherever your downloads can be found, depending on your OS configuration).\n",
     "\n",

docs/docs/integrations/document_loaders/web_base.ipynb

@@ -76,7 +76,7 @@
    "source": [
     "To bypass SSL verification errors during fetching, you can set the \"verify\" option:\n",
     "\n",
-    "loader.requests_kwargs = {'verify':False}\n",
+    "`loader.requests_kwargs = {'verify':False}`\n",
     "\n",
     "### Initialization with multiple pages\n",
     "\n",

docs/docs/integrations/llm_caching.ipynb

@@ -14,7 +14,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "id": "88486f6f",
    "metadata": {},
    "outputs": [],
@@ -30,7 +30,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "id": "10ad9224",
    "metadata": {
     "ExecuteTime": {
@@ -2400,7 +2400,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 4,
    "id": "9b4764e4-c75f-4185-b326-524287a826be",
    "metadata": {},
    "outputs": [],
@@ -2430,7 +2430,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 5,
    "id": "4b5e73c5-92c1-4eab-84e2-77924ea9c123",
    "metadata": {},
    "outputs": [],
@@ -2452,7 +2452,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 6,
    "id": "db8d28cc-8d93-47b4-8326-57a29a06fb3c",
    "metadata": {},
    "outputs": [
@@ -2483,7 +2483,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 7,
    "id": "b470dc81-2e7f-4743-9435-ce9071394eea",
    "metadata": {},
    "outputs": [
@@ -2491,17 +2491,17 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 53 ms, sys: 29 ms, total: 82 ms\n",
-      "Wall time: 84.2 ms\n"
+      "CPU times: user 25.9 ms, sys: 15.3 ms, total: 41.3 ms\n",
+      "Wall time: 144 ms\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "\"\\n\\nWhy couldn't the bicycle stand up by itself? Because it was two-tired!\""
+       "\"\\n\\nWhy don't scientists trust atoms?\\n\\nBecause they make up everything.\""
       ]
      },
-     "execution_count": 5,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -2512,6 +2512,35 @@
     "llm.invoke(\"Tell me a joke\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "1dca39d8-233a-45ba-ad7d-0920dfbc4a50",
+   "metadata": {},
+   "source": [
+    "### Specifying a Time to Live (TTL) for the Cached entries\n",
+    "The Cached documents can be deleted after a specified time automatically by specifying a `ttl` parameter along with the initialization of the Cache."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "a3edcc6f-2ccd-45ba-8ca4-f65b5e51b461",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from datetime import timedelta\n",
+    "\n",
+    "set_llm_cache(\n",
+    "    CouchbaseCache(\n",
+    "        cluster=cluster,\n",
+    "        bucket_name=BUCKET_NAME,\n",
+    "        scope_name=SCOPE_NAME,\n",
+    "        collection_name=COLLECTION_NAME,\n",
+    "        ttl=timedelta(minutes=5),\n",
+    "    )\n",
+    ")"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "43626f33-d184-4260-b641-c9341cef5842",
@@ -2523,7 +2552,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 9,
    "id": "6b470c03-d7fe-4270-89e1-638251619a53",
    "metadata": {},
    "outputs": [],
@@ -2653,7 +2682,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 10,
    "id": "ae0766c8-ea34-4604-b0dc-cf2bbe8077f4",
    "metadata": {},
    "outputs": [],
@@ -2679,7 +2708,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 11,
    "id": "a2e82743-10ea-4319-b43e-193475ae5449",
    "metadata": {},
    "outputs": [
@@ -2703,7 +2732,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 12,
    "id": "c36f4e29-d872-4334-a1f1-0e6d10c5d9f2",
    "metadata": {},
    "outputs": [
@@ -2725,6 +2754,38 @@
     "print(llm.invoke(\"What is the expected lifespan of a dog?\"))"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "f6f674fa-70b5-4cf9-a208-992aad2c3c89",
+   "metadata": {},
+   "source": [
+    "### Specifying a Time to Live (TTL) for the Cached entries\n",
+    "The Cached documents can be deleted after a specified time automatically by specifying a `ttl` parameter along with the initialization of the Cache."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "7e127d0a-5049-47e0-abf4-6424ad7d9fec",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from datetime import timedelta\n",
+    "\n",
+    "set_llm_cache(\n",
+    "    CouchbaseSemanticCache(\n",
+    "        cluster=cluster,\n",
+    "        embedding=embeddings,\n",
+    "        bucket_name=BUCKET_NAME,\n",
+    "        scope_name=SCOPE_NAME,\n",
+    "        collection_name=COLLECTION_NAME,\n",
+    "        index_name=INDEX_NAME,\n",
+    "        score_threshold=0.8,\n",
+    "        ttl=timedelta(minutes=5),\n",
+    "    )\n",
+    ")"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "ae1f5e1c-085e-4998-9f2d-b5867d2c3d5b",
@@ -2802,7 +2863,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.3"
+   "version": "3.10.13"
   }
  },
  "nbformat": 4,

docs/docs/integrations/llms/index.mdx

@@ -12,7 +12,7 @@ You are currently on a page documenting the use of [text completion models](/doc
 Unless you are specifically using more advanced prompting techniques, you are probably looking for [this page instead](/docs/integrations/chat/).
 :::
 
-[LLMs](docs/concepts/#llms) are language models that take a string as input and return a string as output.
+[LLMs](/docs/concepts/#llms) are language models that take a string as input and return a string as output.
 
 :::info
 

docs/docs/integrations/llms/runhouse.ipynb

@@ -277,7 +277,7 @@
    "id": "af08575f",
    "metadata": {},
    "source": [
-    "You can send your pipeline directly over the wire to your model, but this will only work for small models (<2 Gb), and will be pretty slow:"
+    "You can send your pipeline directly over the wire to your model, but this will only work for small models (&lt;2 Gb), and will be pretty slow:"
    ]
   },
   {

docs/docs/integrations/memory/couchbase_chat_message_history.ipynb

@@ -1,325 +1,354 @@
 {
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "a283d2fd-e26e-4811-a486-d3cf0ecf6749",
-   "metadata": {},
-   "source": [
-    "# Couchbase\n",
-    "> Couchbase is an award-winning distributed NoSQL cloud database that delivers unmatched versatility, performance, scalability, and financial value for all of your cloud, mobile, AI, and edge computing applications. Couchbase embraces AI with coding assistance for developers and vector search for their applications.\n",
-    "\n",
-    "This notebook goes over how to use the `CouchbaseChatMessageHistory` class to store the chat message history in a Couchbase cluster\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "ff868a6c-3e17-4c3d-8d32-67b01f4d7bcc",
-   "metadata": {},
-   "source": [
-    "## Set Up Couchbase Cluster\n",
-    "To run this demo, you need a Couchbase Cluster. \n",
-    "\n",
-    "You can work with both [Couchbase Capella](https://www.couchbase.com/products/capella/) and your self-managed Couchbase Server."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "41fa85e7-6968-45e4-a445-de305d80f332",
-   "metadata": {},
-   "source": [
-    "## Install Dependencies\n",
-    "`CouchbaseChatMessageHistory` lives inside the `langchain-couchbase` package. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "b744ca05-b8c6-458c-91df-f50ca2c20b3c",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Note: you may need to restart the kernel to use updated packages.\n"
-     ]
-    }
-   ],
-   "source": [
-    "%pip install --upgrade --quiet langchain-couchbase"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "41f29205-6452-493b-ba18-8a3b006bcca4",
-   "metadata": {},
-   "source": [
-    "## Create Couchbase Connection Object\n",
-    "We create a connection to the Couchbase cluster initially and then pass the cluster object to the Vector Store. \n",
-    "\n",
-    "Here, we are connecting using the username and password. You can also connect using any other supported way to your cluster. \n",
-    "\n",
-    "For more information on connecting to the Couchbase cluster, please check the [Python SDK documentation](https://docs.couchbase.com/python-sdk/current/hello-world/start-using-sdk.html#connect)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "f394908e-f5fe-408a-84d7-b97fdebcfa26",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "COUCHBASE_CONNECTION_STRING = (\n",
-    "    \"couchbase://localhost\"  # or \"couchbases://localhost\" if using TLS\n",
-    ")\n",
-    "DB_USERNAME = \"Administrator\"\n",
-    "DB_PASSWORD = \"Password\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "ad4dce21-d80c-465a-b709-fd366ba5ce35",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from datetime import timedelta\n",
-    "\n",
-    "from couchbase.auth import PasswordAuthenticator\n",
-    "from couchbase.cluster import Cluster\n",
-    "from couchbase.options import ClusterOptions\n",
-    "\n",
-    "auth = PasswordAuthenticator(DB_USERNAME, DB_PASSWORD)\n",
-    "options = ClusterOptions(auth)\n",
-    "cluster = Cluster(COUCHBASE_CONNECTION_STRING, options)\n",
-    "\n",
-    "# Wait until the cluster is ready for use.\n",
-    "cluster.wait_until_ready(timedelta(seconds=5))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "e3d0210c-e2e6-437a-86f3-7397a1899fef",
-   "metadata": {},
-   "source": [
-    "We will now set the bucket, scope, and collection names in the Couchbase cluster that we want to use for storing the message history.\n",
-    "\n",
-    "Note that the bucket, scope, and collection need to exist before using them to store the message history."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "e8c7f846-a5c4-4465-a40e-4a9a23ac71bd",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "BUCKET_NAME = \"langchain-testing\"\n",
-    "SCOPE_NAME = \"_default\"\n",
-    "COLLECTION_NAME = \"conversational_cache\""
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "283959e1-6af7-4768-9211-5b0facc6ef65",
-   "metadata": {},
-   "source": [
-    "## Usage\n",
-    "In order to store the messages, you need the following:\n",
-    "- Couchbase Cluster object: Valid connection to the Couchbase cluster\n",
-    "- bucket_name: Bucket in cluster to store the chat message history\n",
-    "- scope_name: Scope in bucket to store the message history\n",
-    "- collection_name: Collection in scope to store the message history\n",
-    "- session_id: Unique identifier for the session\n",
-    "\n",
-    "Optionally you can configure the following:\n",
-    "- session_id_key: Field in the chat message documents to store the `session_id`\n",
-    "- message_key: Field in the chat message documents to store the message content\n",
-    "- create_index: Used to specify if the index needs to be created on the collection. By default, an index is created on the `message_key` and the `session_id_key` of the documents"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "43c3b2d5-aae2-44a9-9e9f-f10adf054cfa",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_couchbase.chat_message_histories import CouchbaseChatMessageHistory\n",
-    "\n",
-    "message_history = CouchbaseChatMessageHistory(\n",
-    "    cluster=cluster,\n",
-    "    bucket_name=BUCKET_NAME,\n",
-    "    scope_name=SCOPE_NAME,\n",
-    "    collection_name=COLLECTION_NAME,\n",
-    "    session_id=\"test-session\",\n",
-    ")\n",
-    "\n",
-    "message_history.add_user_message(\"hi!\")\n",
-    "\n",
-    "message_history.add_ai_message(\"how are you doing?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "e7e348ef-79e9-481c-aeef-969ae03dea6a",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[HumanMessage(content='hi!'), AIMessage(content='how are you doing?')]"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "message_history.messages"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c8b942a7-93fa-4cd9-8414-d047135c2733",
-   "metadata": {},
-   "source": [
-    "## Chaining\n",
-    "The chat message history class can be used with [LCEL Runnables](https://python.langchain.com/docs/how_to/message_history/)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8a9f0d91-d1d6-481d-8137-ea11229f485a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import getpass\n",
-    "import os\n",
-    "\n",
-    "from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n",
-    "from langchain_core.runnables.history import RunnableWithMessageHistory\n",
-    "from langchain_openai import ChatOpenAI\n",
-    "\n",
-    "os.environ[\"OPENAI_API_KEY\"] = getpass.getpass()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "946d45aa-5a61-49ae-816b-1c3949c56d9a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "prompt = ChatPromptTemplate.from_messages(\n",
-    "    [\n",
-    "        (\"system\", \"You are a helpful assistant.\"),\n",
-    "        MessagesPlaceholder(variable_name=\"history\"),\n",
-    "        (\"human\", \"{question}\"),\n",
-    "    ]\n",
-    ")\n",
-    "\n",
-    "# Create the LCEL runnable\n",
-    "chain = prompt | ChatOpenAI()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "20dfd838-b549-42ed-b3ba-ac005f7e024c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "chain_with_history = RunnableWithMessageHistory(\n",
-    "    chain,\n",
-    "    lambda session_id: CouchbaseChatMessageHistory(\n",
-    "        cluster=cluster,\n",
-    "        bucket_name=BUCKET_NAME,\n",
-    "        scope_name=SCOPE_NAME,\n",
-    "        collection_name=COLLECTION_NAME,\n",
-    "        session_id=session_id,\n",
-    "    ),\n",
-    "    input_messages_key=\"question\",\n",
-    "    history_messages_key=\"history\",\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "17bd09f4-896d-433d-bb9a-369a06e7aa8a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# This is where we configure the session id\n",
-    "config = {\"configurable\": {\"session_id\": \"testing\"}}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "4bda1096-2fc2-40d7-a046-0d5d8e3a8f75",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "AIMessage(content='Hello Bob! How can I assist you today?', response_metadata={'token_usage': {'completion_tokens': 10, 'prompt_tokens': 22, 'total_tokens': 32}, 'model_name': 'gpt-4o-mini', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-a0f8a29e-ddf4-4e06-a1fe-cf8c325a2b72-0', usage_metadata={'input_tokens': 22, 'output_tokens': 10, 'total_tokens': 32})"
-      ]
-     },
-     "execution_count": 11,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "chain_with_history.invoke({\"question\": \"Hi! I'm bob\"}, config=config)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "1cfb31da-51bb-4c5f-909a-b7118b0ae08d",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "AIMessage(content='Your name is Bob.', response_metadata={'token_usage': {'completion_tokens': 5, 'prompt_tokens': 43, 'total_tokens': 48}, 'model_name': 'gpt-4o-mini', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-f764a9eb-999e-4042-96b6-fe47b7ae4779-0', usage_metadata={'input_tokens': 43, 'output_tokens': 5, 'total_tokens': 48})"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "chain_with_history.invoke({\"question\": \"Whats my name\"}, config=config)"
-   ]
-  }
- ],
- "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.10.13"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
+       "cells": [
+              {
+                     "cell_type": "markdown",
+                     "id": "a283d2fd-e26e-4811-a486-d3cf0ecf6749",
+                     "metadata": {},
+                     "source": [
+                            "# Couchbase\n",
+                            "> Couchbase is an award-winning distributed NoSQL cloud database that delivers unmatched versatility, performance, scalability, and financial value for all of your cloud, mobile, AI, and edge computing applications. Couchbase embraces AI with coding assistance for developers and vector search for their applications.\n",
+                            "\n",
+                            "This notebook goes over how to use the `CouchbaseChatMessageHistory` class to store the chat message history in a Couchbase cluster\n"
+                     ]
+              },
+              {
+                     "cell_type": "markdown",
+                     "id": "ff868a6c-3e17-4c3d-8d32-67b01f4d7bcc",
+                     "metadata": {},
+                     "source": [
+                            "## Set Up Couchbase Cluster\n",
+                            "To run this demo, you need a Couchbase Cluster. \n",
+                            "\n",
+                            "You can work with both [Couchbase Capella](https://www.couchbase.com/products/capella/) and your self-managed Couchbase Server."
+                     ]
+              },
+              {
+                     "cell_type": "markdown",
+                     "id": "41fa85e7-6968-45e4-a445-de305d80f332",
+                     "metadata": {},
+                     "source": [
+                            "## Install Dependencies\n",
+                            "`CouchbaseChatMessageHistory` lives inside the `langchain-couchbase` package. "
+                     ]
+              },
+              {
+                     "cell_type": "code",
+                     "execution_count": 1,
+                     "id": "b744ca05-b8c6-458c-91df-f50ca2c20b3c",
+                     "metadata": {},
+                     "outputs": [
+                            {
+                                   "name": "stdout",
+                                   "output_type": "stream",
+                                   "text": [
+                                          "Note: you may need to restart the kernel to use updated packages.\n"
+                                   ]
+                            }
+                     ],
+                     "source": [
+                            "%pip install --upgrade --quiet langchain-couchbase"
+                     ]
+              },
+              {
+                     "cell_type": "markdown",
+                     "id": "41f29205-6452-493b-ba18-8a3b006bcca4",
+                     "metadata": {},
+                     "source": [
+                            "## Create Couchbase Connection Object\n",
+                            "We create a connection to the Couchbase cluster initially and then pass the cluster object to the Vector Store. \n",
+                            "\n",
+                            "Here, we are connecting using the username and password. You can also connect using any other supported way to your cluster. \n",
+                            "\n",
+                            "For more information on connecting to the Couchbase cluster, please check the [Python SDK documentation](https://docs.couchbase.com/python-sdk/current/hello-world/start-using-sdk.html#connect)."
+                     ]
+              },
+              {
+                     "cell_type": "code",
+                     "execution_count": 2,
+                     "id": "f394908e-f5fe-408a-84d7-b97fdebcfa26",
+                     "metadata": {},
+                     "outputs": [],
+                     "source": [
+                            "COUCHBASE_CONNECTION_STRING = (\n",
+                            "    \"couchbase://localhost\"  # or \"couchbases://localhost\" if using TLS\n",
+                            ")\n",
+                            "DB_USERNAME = \"Administrator\"\n",
+                            "DB_PASSWORD = \"Password\""
+                     ]
+              },
+              {
+                     "cell_type": "code",
+                     "execution_count": 3,
+                     "id": "ad4dce21-d80c-465a-b709-fd366ba5ce35",
+                     "metadata": {},
+                     "outputs": [],
+                     "source": [
+                            "from datetime import timedelta\n",
+                            "\n",
+                            "from couchbase.auth import PasswordAuthenticator\n",
+                            "from couchbase.cluster import Cluster\n",
+                            "from couchbase.options import ClusterOptions\n",
+                            "\n",
+                            "auth = PasswordAuthenticator(DB_USERNAME, DB_PASSWORD)\n",
+                            "options = ClusterOptions(auth)\n",
+                            "cluster = Cluster(COUCHBASE_CONNECTION_STRING, options)\n",
+                            "\n",
+                            "# Wait until the cluster is ready for use.\n",
+                            "cluster.wait_until_ready(timedelta(seconds=5))"
+                     ]
+              },
+              {
+                     "cell_type": "markdown",
+                     "id": "e3d0210c-e2e6-437a-86f3-7397a1899fef",
+                     "metadata": {},
+                     "source": [
+                            "We will now set the bucket, scope, and collection names in the Couchbase cluster that we want to use for storing the message history.\n",
+                            "\n",
+                            "Note that the bucket, scope, and collection need to exist before using them to store the message history."
+                     ]
+              },
+              {
+                     "cell_type": "code",
+                     "execution_count": 4,
+                     "id": "e8c7f846-a5c4-4465-a40e-4a9a23ac71bd",
+                     "metadata": {},
+                     "outputs": [],
+                     "source": [
+                            "BUCKET_NAME = \"langchain-testing\"\n",
+                            "SCOPE_NAME = \"_default\"\n",
+                            "COLLECTION_NAME = \"conversational_cache\""
+                     ]
+              },
+              {
+                     "cell_type": "markdown",
+                     "id": "283959e1-6af7-4768-9211-5b0facc6ef65",
+                     "metadata": {},
+                     "source": [
+                            "## Usage\n",
+                            "In order to store the messages, you need the following:\n",
+                            "- Couchbase Cluster object: Valid connection to the Couchbase cluster\n",
+                            "- bucket_name: Bucket in cluster to store the chat message history\n",
+                            "- scope_name: Scope in bucket to store the message history\n",
+                            "- collection_name: Collection in scope to store the message history\n",
+                            "- session_id: Unique identifier for the session\n",
+                            "\n",
+                            "Optionally you can configure the following:\n",
+                            "- session_id_key: Field in the chat message documents to store the `session_id`\n",
+                            "- message_key: Field in the chat message documents to store the message content\n",
+                            "- create_index: Used to specify if the index needs to be created on the collection. By default, an index is created on the `message_key` and the `session_id_key` of the documents\n",
+                            "- ttl: Used to specify a time in `timedelta` to live for the documents after which they will get deleted automatically from the storage."
+                     ]
+              },
+              {
+                     "cell_type": "code",
+                     "execution_count": 5,
+                     "id": "43c3b2d5-aae2-44a9-9e9f-f10adf054cfa",
+                     "metadata": {},
+                     "outputs": [],
+                     "source": [
+                            "from langchain_couchbase.chat_message_histories import CouchbaseChatMessageHistory\n",
+                            "\n",
+                            "message_history = CouchbaseChatMessageHistory(\n",
+                            "    cluster=cluster,\n",
+                            "    bucket_name=BUCKET_NAME,\n",
+                            "    scope_name=SCOPE_NAME,\n",
+                            "    collection_name=COLLECTION_NAME,\n",
+                            "    session_id=\"test-session\",\n",
+                            ")\n",
+                            "\n",
+                            "message_history.add_user_message(\"hi!\")\n",
+                            "\n",
+                            "message_history.add_ai_message(\"how are you doing?\")"
+                     ]
+              },
+              {
+                     "cell_type": "code",
+                     "execution_count": 6,
+                     "id": "e7e348ef-79e9-481c-aeef-969ae03dea6a",
+                     "metadata": {},
+                     "outputs": [
+                            {
+                                   "data": {
+                                          "text/plain": [
+                                                 "[HumanMessage(content='hi!'), AIMessage(content='how are you doing?')]"
+                                          ]
+                                   },
+                                   "execution_count": 6,
+                                   "metadata": {},
+                                   "output_type": "execute_result"
+                            }
+                     ],
+                     "source": [
+                            "message_history.messages"
+                     ]
+              },
+              {
+                     "cell_type": "markdown",
+                     "id": "b993fe69-4462-4cb4-ad0a-eb31a1a4d7d9",
+                     "metadata": {},
+                     "source": [
+                            "## Specifying a Time to Live (TTL) for the Chat Messages\n",
+                            "The stored messages can be deleted after a specified time automatically by specifying a `ttl` parameter along with the initialization of the chat message history store."
+                     ]
+              },
+              {
+                     "cell_type": "code",
+                     "execution_count": 7,
+                     "id": "d32d9302-de97-4319-a484-c83530bab508",
+                     "metadata": {},
+                     "outputs": [],
+                     "source": [
+                            "from langchain_couchbase.chat_message_histories import CouchbaseChatMessageHistory\n",
+                            "\n",
+                            "message_history = CouchbaseChatMessageHistory(\n",
+                            "    cluster=cluster,\n",
+                            "    bucket_name=BUCKET_NAME,\n",
+                            "    scope_name=SCOPE_NAME,\n",
+                            "    collection_name=COLLECTION_NAME,\n",
+                            "    session_id=\"test-session\",\n",
+                            "    ttl=timedelta(hours=24),\n",
+                            ")"
+                     ]
+              },
+              {
+                     "cell_type": "markdown",
+                     "id": "c8b942a7-93fa-4cd9-8414-d047135c2733",
+                     "metadata": {},
+                     "source": [
+                            "## Chaining\n",
+                            "The chat message history class can be used with [LCEL Runnables](https://python.langchain.com/docs/how_to/message_history/)"
+                     ]
+              },
+              {
+                     "cell_type": "code",
+                     "execution_count": 8,
+                     "id": "8a9f0d91-d1d6-481d-8137-ea11229f485a",
+                     "metadata": {},
+                     "outputs": [],
+                     "source": [
+                            "import getpass\n",
+                            "import os\n",
+                            "\n",
+                            "from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n",
+                            "from langchain_core.runnables.history import RunnableWithMessageHistory\n",
+                            "from langchain_openai import ChatOpenAI\n",
+                            "\n",
+                            "os.environ[\"OPENAI_API_KEY\"] = getpass.getpass()"
+                     ]
+              },
+              {
+                     "cell_type": "code",
+                     "execution_count": 9,
+                     "id": "946d45aa-5a61-49ae-816b-1c3949c56d9a",
+                     "metadata": {},
+                     "outputs": [],
+                     "source": [
+                            "prompt = ChatPromptTemplate.from_messages(\n",
+                            "    [\n",
+                            "        (\"system\", \"You are a helpful assistant.\"),\n",
+                            "        MessagesPlaceholder(variable_name=\"history\"),\n",
+                            "        (\"human\", \"{question}\"),\n",
+                            "    ]\n",
+                            ")\n",
+                            "\n",
+                            "# Create the LCEL runnable\n",
+                            "chain = prompt | ChatOpenAI()"
+                     ]
+              },
+              {
+                     "cell_type": "code",
+                     "execution_count": 10,
+                     "id": "20dfd838-b549-42ed-b3ba-ac005f7e024c",
+                     "metadata": {},
+                     "outputs": [],
+                     "source": [
+                            "chain_with_history = RunnableWithMessageHistory(\n",
+                            "    chain,\n",
+                            "    lambda session_id: CouchbaseChatMessageHistory(\n",
+                            "        cluster=cluster,\n",
+                            "        bucket_name=BUCKET_NAME,\n",
+                            "        scope_name=SCOPE_NAME,\n",
+                            "        collection_name=COLLECTION_NAME,\n",
+                            "        session_id=session_id,\n",
+                            "    ),\n",
+                            "    input_messages_key=\"question\",\n",
+                            "    history_messages_key=\"history\",\n",
+                            ")"
+                     ]
+              },
+              {
+                     "cell_type": "code",
+                     "execution_count": 11,
+                     "id": "17bd09f4-896d-433d-bb9a-369a06e7aa8a",
+                     "metadata": {},
+                     "outputs": [],
+                     "source": [
+                            "# This is where we configure the session id\n",
+                            "config = {\"configurable\": {\"session_id\": \"testing\"}}"
+                     ]
+              },
+              {
+                     "cell_type": "code",
+                     "execution_count": 12,
+                     "id": "4bda1096-2fc2-40d7-a046-0d5d8e3a8f75",
+                     "metadata": {},
+                     "outputs": [
+                            {
+                                   "data": {
+                                          "text/plain": [
+                                                 "AIMessage(content='Hello, Bob! How can I assist you today?', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 11, 'prompt_tokens': 22, 'total_tokens': 33}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-62e54e3d-db70-429d-9ee0-e5e8eb2489a1-0', usage_metadata={'input_tokens': 22, 'output_tokens': 11, 'total_tokens': 33})"
+                                          ]
+                                   },
+                                   "execution_count": 12,
+                                   "metadata": {},
+                                   "output_type": "execute_result"
+                            }
+                     ],
+                     "source": [
+                            "chain_with_history.invoke({\"question\": \"Hi! I'm bob\"}, config=config)"
+                     ]
+              },
+              {
+                     "cell_type": "code",
+                     "execution_count": 13,
+                     "id": "1cfb31da-51bb-4c5f-909a-b7118b0ae08d",
+                     "metadata": {},
+                     "outputs": [
+                            {
+                                   "data": {
+                                          "text/plain": [
+                                                 "AIMessage(content='Your name is Bob.', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 5, 'prompt_tokens': 44, 'total_tokens': 49}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-d84a570a-45f3-4931-814a-078761170bca-0', usage_metadata={'input_tokens': 44, 'output_tokens': 5, 'total_tokens': 49})"
+                                          ]
+                                   },
+                                   "execution_count": 13,
+                                   "metadata": {},
+                                   "output_type": "execute_result"
+                            }
+                     ],
+                     "source": [
+                            "chain_with_history.invoke({\"question\": \"Whats my name\"}, config=config)"
+                     ]
+              }
+       ],
+       "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.10.13"
+              }
+       },
+       "nbformat": 4,
+       "nbformat_minor": 5
+}

docs/docs/integrations/providers/cnosdb.mdx

@@ -101,7 +101,7 @@ pressure	station	temperature	time	visibility
 */
 Thought:The "temperature" column in the "air" table is relevant to the question. I can query the average temperature between the specified dates.
 Action: sql_db_query
-Action Input: "SELECT AVG(temperature) FROM air WHERE station = 'XiaoMaiDao' AND time >= '2022-10-19' AND time <= '2022-10-20'"
+Action Input: "SELECT AVG(temperature) FROM air WHERE station = 'XiaoMaiDao' AND time >= '2022-10-19' AND time &lt;= '2022-10-20'"
 Observation: [(68.0,)]
 Thought:The average temperature of air at station XiaoMaiDao between October 19, 2022 and October 20, 2022 is 68.0.
 Final Answer: 68.0

docs/docs/integrations/providers/dspy.ipynb

@@ -190,7 +190,7 @@
     " \n",
     "Let's use LangChain's expression language (LCEL) to illustrate this. Any prompt here will do, we will optimize the final prompt with DSPy.\n",
     "\n",
-    "Considering that, let's just keep it to the barebones: **Given {context}, answer the question {question} as a tweet.**"
+    "Considering that, let's just keep it to the barebones: **Given \\{context\\}, answer the question \\{question\\} as a tweet.**"
    ]
   },
   {

docs/docs/integrations/providers/figma.mdx

@@ -6,9 +6,9 @@
 
 The Figma API requires an `access token`, `node_ids`, and a `file key`.
 
-The `file key` can be pulled from the URL.  https://www.figma.com/file/{filekey}/sampleFilename
+The `file key` can be pulled from the URL.  https://www.figma.com/file/\{filekey\}/sampleFilename
 
-`Node IDs` are also available in the URL. Click on anything and look for the '?node-id={node_id}' param.
+`Node IDs` are also available in the URL. Click on anything and look for the '?node-id=\{node_id\}' param.
 
 `Access token` [instructions](https://help.figma.com/hc/en-us/articles/8085703771159-Manage-personal-access-tokens).
 

docs/docs/integrations/providers/premai.md

@@ -229,9 +229,10 @@ query_result = embedder.embed_query(query)
 
 print(query_result[:5])
 ```
-<Note>
+
+:::note
 Setting `model_name` argument in mandatory for PremAIEmbeddings unlike chat. 
-</Note>
+:::
 
 Finally, let's embed some sample document
 

docs/docs/integrations/providers/xinference.mdx

@@ -60,7 +60,7 @@ Xinference client.
 For local deployment, the endpoint will be http://localhost:9997. 
 
 
-For cluster deployment, the endpoint will be http://${supervisor_host}:9997.
+For cluster deployment, the endpoint will be http://$\{supervisor_host\}:9997.
 
 
 Then, you need to launch a model. You can specify the model names and other attributes 

docs/docs/integrations/retrievers/arxiv.ipynb

@@ -215,11 +215,9 @@
     "\n",
     "We will need a LLM or chat model:\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
-    "<ChatModelTabs customVarName=\"llm\" />\n",
-    "```"
+    "<ChatModelTabs customVarName=\"llm\" />\n"
    ]
   },
   {

docs/docs/integrations/retrievers/box.ipynb

@@ -248,11 +248,9 @@
     "\n",
     "We will need a LLM or chat model:\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
-    "<ChatModelTabs customVarName=\"llm\" />\n",
-    "```"
+    "<ChatModelTabs customVarName=\"llm\" />\n"
    ]
   },
   {

docs/docs/integrations/retrievers/weaviate-hybrid.ipynb

@@ -62,16 +62,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "f47a2bfe",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": []
-    }
-   ],
+   "outputs": [],
    "source": [
     "from langchain_community.retrievers import (\n",
     "    WeaviateHybridSearchRetriever,\n",

docs/docs/integrations/retrievers/wikipedia.ipynb

@@ -152,11 +152,9 @@
     "\n",
     "We will need a LLM or chat model:\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
-    "<ChatModelTabs customVarName=\"llm\" />\n",
-    "```"
+    "<ChatModelTabs customVarName=\"llm\" />\n"
    ]
   },
   {

docs/docs/integrations/tools/chatgpt_plugins.ipynb

@@ -17,13 +17,11 @@
    "source": [
     "# ChatGPT Plugins\n",
     "\n",
-    "```{=mdx}\n",
     ":::warning Deprecated\n",
     "\n",
     "OpenAI has [deprecated plugins](https://openai.com/index/chatgpt-plugins/).\n",
     "\n",
     ":::\n",
-    "```\n",
     "\n",
     "This example shows how to use ChatGPT Plugins within LangChain abstractions.\n",
     "\n",

docs/docs/integrations/tools/exa_search.ipynb

@@ -69,7 +69,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    ":::{.callout-note}\n",
+    ":::note\n",
     "\n",
     "The `max_characters` parameter for **TextContentsOptions** used to be called `max_length` which is now deprecated. Make sure to use `max_characters` instead.\n",
     "\n",

docs/docs/integrations/tools/github.ipynb

@@ -81,7 +81,7 @@
     "\n",
     "* **GITHUB_APP_ID**- A six digit number found in your app's general settings\n",
     "* **GITHUB_APP_PRIVATE_KEY**- The location of your app's private key .pem file, or the full text of that file as a string.\n",
-    "* **GITHUB_REPOSITORY**- The name of the Github repository you want your bot to act upon. Must follow the format {username}/{repo-name}. *Make sure the app has been added to this repository first!*\n",
+    "* **GITHUB_REPOSITORY**- The name of the Github repository you want your bot to act upon. Must follow the format \\{username\\}/\\{repo-name\\}. *Make sure the app has been added to this repository first!*\n",
     "* Optional: **GITHUB_BRANCH**- The branch where the bot will make its commits. Defaults to `repo.default_branch`.\n",
     "* Optional: **GITHUB_BASE_BRANCH**- The base branch of your repo upon which PRs will based from. Defaults to `repo.default_branch`."
    ]
@@ -208,11 +208,9 @@
     "\n",
     "We will need a LLM or chat model:\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
-    "<ChatModelTabs customVarName=\"llm\" />\n",
-    "```"
+    "<ChatModelTabs customVarName=\"llm\" />\n"
    ]
   },
   {

docs/docs/integrations/tools/gitlab.ipynb

@@ -80,7 +80,7 @@
     "\n",
     "* **GITLAB_URL** - The URL hosted Gitlab. Defaults to \"https://gitlab.com\". \n",
     "* **GITLAB_PERSONAL_ACCESS_TOKEN**- The personal access token you created in the last step\n",
-    "* **GITLAB_REPOSITORY**- The name of the Gitlab repository you want your bot to act upon. Must follow the format {username}/{repo-name}.\n",
+    "* **GITLAB_REPOSITORY**- The name of the Gitlab repository you want your bot to act upon. Must follow the format \\{username\\}/\\{repo-name\\}.\n",
     "* **GITLAB_BRANCH**- The branch where the bot will make its commits. Defaults to 'main.'\n",
     "* **GITLAB_BASE_BRANCH**- The base branch of your repo, usually either 'main' or 'master.' This is where merge requests will base from. Defaults to 'main.'\n"
    ]

docs/docs/integrations/tools/gmail.ipynb

@@ -159,11 +159,9 @@
     "\n",
     "We will need a LLM or chat model:\n",
     "\n",
-    "```{=mdx}\n",
     "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
     "\n",
-    "<ChatModelTabs customVarName=\"llm\" />\n",
-    "```"
+    "<ChatModelTabs customVarName=\"llm\" />\n"
    ]
   },
   {

docs/docs/integrations/tools/ifttt.ipynb

@@ -31,7 +31,7 @@
     "- Configure the action by specifying the necessary details, such as the playlist name,\n",
     "e.g., \"Songs from AI\".\n",
     "- Reference the JSON Payload received by the Webhook in your action. For the Spotify\n",
-    "scenario, choose \"{{JsonPayload}}\" as your search query.\n",
+    "scenario, choose `{{JsonPayload}}` as your search query.\n",
     "- Tap the \"Create Action\" button to save your action settings.\n",
     "- Once you have finished configuring your action, click the \"Finish\" button to\n",
     "complete the setup.\n",

docs/docs/integrations/tools/lemonai.ipynb

@@ -137,7 +137,7 @@
    "source": [
     "#### Load API Keys and Access Tokens\n",
     "\n",
-    "To use tools that require authentication, you have to store the corresponding access credentials in your environment in the format \"{tool name}_{authentication string}\" where the authentication string is one of [\"API_KEY\", \"SECRET_KEY\", \"SUBSCRIPTION_KEY\", \"ACCESS_KEY\"] for API keys or [\"ACCESS_TOKEN\", \"SECRET_TOKEN\"] for authentication tokens. Examples are \"OPENAI_API_KEY\", \"BING_SUBSCRIPTION_KEY\", \"AIRTABLE_ACCESS_TOKEN\"."
+    "To use tools that require authentication, you have to store the corresponding access credentials in your environment in the format `\"{tool name}_{authentication string}\"` where the authentication string is one of [\"API_KEY\", \"SECRET_KEY\", \"SUBSCRIPTION_KEY\", \"ACCESS_KEY\"] for API keys or [\"ACCESS_TOKEN\", \"SECRET_TOKEN\"] for authentication tokens. Examples are \"OPENAI_API_KEY\", \"BING_SUBSCRIPTION_KEY\", \"AIRTABLE_ACCESS_TOKEN\"."
    ]
   },
   {