docs: update chat openai (#20331)

Note: includes links to API reference pages for ToolCall and other
objects that currently don't exist (e.g.,
https://api.python.langchain.com/en/latest/messages/langchain_core.messages.tool.ToolCall.html#langchain_core.messages.tool.ToolCall).

.github/scripts/check_diff.py

@@ -47,6 +47,16 @@ if __name__ == "__main__":
                     found = True
                 if found:
                     dirs_to_run["extended-test"].add(dir_)
+        elif file.startswith("libs/standard-tests"):
+            # TODO: update to include all packages that rely on standard-tests (all partner packages)
+            # note: won't run on external repo partners
+            dirs_to_run["lint"].add("libs/standard-tests")
+            dirs_to_run["test"].add("libs/partners/mistralai")
+            dirs_to_run["test"].add("libs/partners/openai")
+
+        elif file.startswith("libs/cli"):
+            # todo: add cli makefile
+            pass
         elif file.startswith("libs/partners"):
             partner_dir = file.split("/")[2]
             if os.path.isdir(f"libs/partners/{partner_dir}") and [

.github/scripts/get_min_versions.py

@@ -4,17 +4,25 @@ import tomllib
 from packaging.version import parse as parse_version
 import re
 
-MIN_VERSION_LIBS = ["langchain-core", "langchain-community", "langchain", "langchain-text-splitters"]
+MIN_VERSION_LIBS = [
+    "langchain-core",
+    "langchain-community",
+    "langchain",
+    "langchain-text-splitters",
+]
 
 
 def get_min_version(version: str) -> str:
+    # base regex for x.x.x with cases for rc/post/etc
+    # valid strings: https://peps.python.org/pep-0440/#public-version-identifiers
+    vstring = r"\d+(?:\.\d+){0,2}(?:(?:a|b|rc|\.post|\.dev)\d+)?"
     # case ^x.x.x
-    _match = re.match(r"^\^(\d+(?:\.\d+){0,2})$", version)
+    _match = re.match(f"^\\^({vstring})$", version)
     if _match:
         return _match.group(1)
 
     # case >=x.x.x,<y.y.y
-    _match = re.match(r"^>=(\d+(?:\.\d+){0,2}),<(\d+(?:\.\d+){0,2})$", version)
+    _match = re.match(f"^>=({vstring}),<({vstring})$", version)
     if _match:
         _min = _match.group(1)
         _max = _match.group(2)
@@ -22,7 +30,7 @@ def get_min_version(version: str) -> str:
         return _min
 
     # case x.x.x
-    _match = re.match(r"^(\d+(?:\.\d+){0,2})$", version)
+    _match = re.match(f"^({vstring})$", version)
     if _match:
         return _match.group(1)
 
@@ -47,6 +55,9 @@ def get_min_version_from_toml(toml_path: str):
             # Get the version string
             version_string = dependencies[lib]
 
+            if isinstance(version_string, dict):
+                version_string = version_string["version"]
+
             # Use parse_version to get the minimum supported version from version_string
             min_version = get_min_version(version_string)
 
@@ -56,12 +67,13 @@ def get_min_version_from_toml(toml_path: str):
     return min_versions
 
 
-# Get the TOML file path from the command line argument
-toml_file = sys.argv[1]
+if __name__ == "__main__":
+    # Get the TOML file path from the command line argument
+    toml_file = sys.argv[1]
 
-# Call the function to get the minimum versions
-min_versions = get_min_version_from_toml(toml_file)
+    # Call the function to get the minimum versions
+    min_versions = get_min_version_from_toml(toml_file)
 
-print(
-    " ".join([f"{lib}=={version}" for lib, version in min_versions.items()])
-)  # noqa: T201
+    print(
+        " ".join([f"{lib}=={version}" for lib, version in min_versions.items()])
+    )  # noqa: T201

.github/workflows/_integration_test.yml

@@ -75,6 +75,8 @@ jobs:
           ES_API_KEY: ${{ secrets.ES_API_KEY }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # for airbyte
           MONGODB_ATLAS_URI: ${{ secrets.MONGODB_ATLAS_URI }}
+          VOYAGE_API_KEY: ${{ secrets.VOYAGE_API_KEY }}
+          COHERE_API_KEY: ${{ secrets.COHERE_API_KEY }}
         run: |
           make integration_tests
 

.github/workflows/_release.yml

@@ -55,7 +55,7 @@ jobs:
         working-directory: ${{ inputs.working-directory }}
 
       - name: Upload build
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: dist
           path: ${{ inputs.working-directory }}/dist/
@@ -157,6 +157,24 @@ jobs:
         run: make tests
         working-directory: ${{ inputs.working-directory }}
 
+      - name: Get minimum versions
+        working-directory: ${{ inputs.working-directory }}
+        id: min-version
+        run: |
+          poetry run pip install packaging
+          min_versions="$(poetry run python $GITHUB_WORKSPACE/.github/scripts/get_min_versions.py pyproject.toml)"
+          echo "min-versions=$min_versions" >> "$GITHUB_OUTPUT"
+          echo "min-versions=$min_versions"
+
+      - name: Run unit tests with minimum dependency versions
+        if: ${{ steps.min-version.outputs.min-versions != '' }}
+        env:
+          MIN_VERSIONS: ${{ steps.min-version.outputs.min-versions }}
+        run: |
+          poetry run pip install $MIN_VERSIONS
+          make tests
+        working-directory: ${{ inputs.working-directory }}
+
       - name: 'Authenticate to Google Cloud'
         id: 'auth'
         uses: google-github-actions/auth@v2
@@ -196,27 +214,10 @@ jobs:
           ES_API_KEY: ${{ secrets.ES_API_KEY }}
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # for airbyte
           MONGODB_ATLAS_URI: ${{ secrets.MONGODB_ATLAS_URI }}
+          VOYAGE_API_KEY: ${{ secrets.VOYAGE_API_KEY }}
         run: make integration_tests
         working-directory: ${{ inputs.working-directory }}
 
-      - name: Get minimum versions
-        working-directory: ${{ inputs.working-directory }}
-        id: min-version
-        run: |
-          poetry run pip install packaging
-          min_versions="$(poetry run python $GITHUB_WORKSPACE/.github/scripts/get_min_versions.py pyproject.toml)"
-          echo "min-versions=$min_versions" >> "$GITHUB_OUTPUT"
-          echo "min-versions=$min_versions"
-
-      - name: Run unit tests with minimum dependency versions
-        if: ${{ steps.min-version.outputs.min-versions != '' }}
-        env:
-          MIN_VERSIONS: ${{ steps.min-version.outputs.min-versions }}
-        run: |
-          poetry run pip install $MIN_VERSIONS
-          make tests
-        working-directory: ${{ inputs.working-directory }}
-
   publish:
     needs:
       - build
@@ -246,7 +247,7 @@ jobs:
           working-directory: ${{ inputs.working-directory }}
           cache-key: release
 
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
           name: dist
           path: ${{ inputs.working-directory }}/dist/
@@ -285,7 +286,7 @@ jobs:
           working-directory: ${{ inputs.working-directory }}
           cache-key: release
 
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
           name: dist
           path: ${{ inputs.working-directory }}/dist/

.github/workflows/_test_doc_imports.yml

@@ -0,0 +1,50 @@
+name: test_doc_imports
+
+on:
+  workflow_call:
+
+env:
+  POETRY_VERSION: "1.7.1"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.11"
+    name: "check doc imports #${{ matrix.python-version }}"
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_setup"
+        with:
+          python-version: ${{ matrix.python-version }}
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: core
+
+      - name: Install dependencies
+        shell: bash
+        run: poetry install --with test
+
+      - name: Install langchain editable
+        run: |
+          poetry run pip install -e libs/core libs/langchain libs/community libs/experimental
+
+      - name: Check doc imports
+        shell: bash
+        run: |
+          poetry run python docs/scripts/check_imports.py
+
+      - name: Ensure the test did not create any additional files
+        shell: bash
+        run: |
+          set -eu
+
+          STATUS="$(git status)"
+          echo "$STATUS"
+
+          # grep will exit non-zero if the target message isn't found,
+          # and `set -e` above will cause the step to fail.
+          echo "$STATUS" | grep 'nothing to commit, working tree clean'

.github/workflows/_test_release.yml

@@ -48,7 +48,7 @@ jobs:
         working-directory: ${{ inputs.working-directory }}
 
       - name: Upload build
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: test-dist
           path: ${{ inputs.working-directory }}/dist/
@@ -76,7 +76,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
           name: test-dist
           path: ${{ inputs.working-directory }}/dist/

.github/workflows/check-broken-links.yml

@@ -0,0 +1,24 @@
+name: Check Broken Links
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron:  '0 13 * * *'
+
+jobs:
+  check-links:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Use Node.js 18.x
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18.x
+          cache: "yarn"
+          cache-dependency-path: ./docs/yarn.lock
+      - name: Install dependencies
+        run: yarn install --immutable --mode=skip-build
+        working-directory: ./docs
+      - name: Check broken links
+        run: yarn check-broken-links
+        working-directory: ./docs

.github/workflows/check_diffs.yml

@@ -60,6 +60,12 @@ jobs:
       working-directory: ${{ matrix.working-directory }}
     secrets: inherit
 
+  test_doc_imports:
+    needs: [ build ]
+    if: ${{ needs.build.outputs.dirs-to-test != '[]' }}
+    uses: ./.github/workflows/_test_doc_imports.yml
+    secrets: inherit
+
   compile-integration-tests:
     name: cd ${{ matrix.working-directory }}
     needs: [ build ]

.gitignore

@@ -116,6 +116,7 @@ celerybeat.pid
 .env
 .envrc
 .venv*
+venv*
 env/
 ENV/
 env.bak/

Makefile

@@ -1,44 +1,56 @@
-.PHONY: all clean docs_build docs_clean docs_linkcheck api_docs_build api_docs_clean api_docs_linkcheck
+.PHONY: all clean help docs_build docs_clean docs_linkcheck api_docs_build api_docs_clean api_docs_linkcheck spell_check spell_fix lint lint_package lint_tests format format_diff
 
-# Default target executed when no arguments are given to make.
+## help: Show this help info.
+help: Makefile
+	@printf "\n\033[1mUsage: make <TARGETS> ...\033[0m\n\n\033[1mTargets:\033[0m\n\n"
+	@sed -n 's/^##//p' $< | awk -F':' '{printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}' | sort | sed -e 's/^/ /'
+
+## all: Default target, shows help.
 all: help
 
+## clean: Clean documentation and API documentation artifacts.
+clean: docs_clean api_docs_clean
 
 ######################
 # DOCUMENTATION
 ######################
 
-clean: docs_clean api_docs_clean
-
-
+## docs_build: Build the documentation.
 docs_build:
 	docs/.local_build.sh
 
+## docs_clean: Clean the documentation build artifacts.
 docs_clean:
 	@if [ -d _dist ]; then \
-			rm -r _dist; \
-			echo "Directory _dist has been cleaned."; \
+		rm -r _dist; \
+		echo "Directory _dist has been cleaned."; \
 	else \
-			echo "Nothing to clean."; \
+		echo "Nothing to clean."; \
 	fi
 
+## docs_linkcheck: Run linkchecker on the documentation.
 docs_linkcheck:
 	poetry run linkchecker _dist/docs/ --ignore-url node_modules
 
+## api_docs_build: Build the API Reference documentation.
 api_docs_build:
 	poetry run python docs/api_reference/create_api_rst.py
 	cd docs/api_reference && poetry run make html
 
+## api_docs_clean: Clean the API Reference documentation build artifacts.
 api_docs_clean:
-	rm -f docs/api_reference/api_reference.rst
+	find ./docs/api_reference -name '*_api_reference.rst' -delete
 	cd docs/api_reference && poetry run make clean
 
+## api_docs_linkcheck: Run linkchecker on the API Reference documentation.
 api_docs_linkcheck:
 	poetry run linkchecker docs/api_reference/_build/html/index.html
 
+## spell_check: Run codespell on the project.
 spell_check:
 	poetry run codespell --toml pyproject.toml
 
+## spell_fix: Run codespell on the project and fix the errors.
 spell_fix:
 	poetry run codespell --toml pyproject.toml -w
 
@@ -46,31 +58,14 @@ spell_fix:
 # LINTING AND FORMATTING
 ######################
 
+## lint: Run linting on the project.
 lint lint_package lint_tests:
 	poetry run ruff docs templates cookbook
 	poetry run ruff format docs templates cookbook --diff
 	poetry run ruff --select I docs templates cookbook
 	git grep 'from langchain import' docs/docs templates cookbook | grep -vE 'from langchain import (hub)' && exit 1 || exit 0
 
+## format: Format the project files.
 format format_diff:
 	poetry run ruff format docs templates cookbook
 	poetry run ruff --select I --fix docs templates cookbook
-
-
-######################
-# HELP
-######################
-
-help:
-	@echo '===================='
-	@echo '-- DOCUMENTATION --'
-	@echo 'clean                        - run docs_clean and api_docs_clean'
-	@echo 'docs_build                   - build the documentation'
-	@echo 'docs_clean                   - clean the documentation build artifacts'
-	@echo 'docs_linkcheck               - run linkchecker on the documentation'
-	@echo 'api_docs_build               - build the API Reference documentation'
-	@echo 'api_docs_clean               - clean the API Reference documentation build artifacts'
-	@echo 'api_docs_linkcheck           - run linkchecker on the API Reference documentation'
-	@echo 'spell_check               	- run codespell on the project'
-	@echo 'spell_fix               		- run codespell on the project and fix the errors'
-	@echo '-- TEST and LINT tasks are within libs/*/ per-package --'

README.md

@@ -34,34 +34,40 @@ conda install langchain -c conda-forge
 
 ## 🤔 What is LangChain?
 
-**LangChain** is a framework for developing applications powered by language models. It enables applications that:
-- **Are context-aware**: connect a language model to sources of context (prompt instructions, few shot examples, content to ground its response in, etc.)
-- **Reason**: rely on a language model to reason (about how to answer based on provided context, what actions to take, etc.)
+**LangChain** is a framework for developing applications powered by large language models (LLMs).
 
-This framework consists of several parts.
-- **LangChain Libraries**: The Python and JavaScript libraries. Contains interfaces and integrations for a myriad of components, a basic run time for combining these components into chains and agents, and off-the-shelf implementations of chains and agents.
-- **[LangChain Templates](templates)**: A collection of easily deployable reference architectures for a wide variety of tasks.
-- **[LangServe](https://github.com/langchain-ai/langserve)**: A library for deploying LangChain chains as a REST API.
-- **[LangSmith](https://smith.langchain.com)**: A developer platform that lets you debug, test, evaluate, and monitor chains built on any LLM framework and seamlessly integrates with LangChain.
-- **[LangGraph](https://python.langchain.com/docs/langgraph)**: LangGraph is a library for building stateful, multi-actor applications with LLMs, built on top of (and intended to be used with) LangChain. It extends the LangChain Expression Language with the ability to coordinate multiple chains (or actors) across multiple steps of computation in a cyclic manner. 
+For these applications, LangChain simplifies the entire application lifecycle:
 
-The LangChain libraries themselves are made up of several different packages.
-- **[`langchain-core`](libs/core)**: Base abstractions and LangChain Expression Language.
-- **[`langchain-community`](libs/community)**: Third party integrations.
-- **[`langchain`](libs/langchain)**: Chains, agents, and retrieval strategies that make up an application's cognitive architecture.
+- **Open-source libraries**: Build your applications using LangChain's [modular building blocks](https://python.langchain.com/docs/expression_language/) and [components](https://python.langchain.com/docs/modules/). Integrate with hundreds of [third-party providers](https://python.langchain.com/docs/integrations/platforms/).
+- **Productionization**: Inspect, monitor, and evaluate your apps with [LangSmith](https://python.langchain.com/docs/langsmith/) so that you can constantly optimize and deploy with confidence.
+- **Deployment**: Turn any chain into a REST API with [LangServe](https://python.langchain.com/docs/langserve).
+
+### Open-source libraries
+- **`langchain-core`**: Base abstractions and LangChain Expression Language.
+- **`langchain-community`**: Third party integrations.
+  - Some integrations have been further split into **partner packages** that only rely on **`langchain-core`**. Examples include **`langchain_openai`** and **`langchain_anthropic`**.
+- **`langchain`**: Chains, agents, and retrieval strategies that make up an application's cognitive architecture.
+- **`[LangGraph](https://python.langchain.com/docs/langgraph)`**: A library for building robust and stateful multi-actor applications with LLMs by modeling steps as edges and nodes in a graph.
+
+### Productionization:
+- **[LangSmith](https://python.langchain.com/docs/langsmith)**: A developer platform that lets you debug, test, evaluate, and monitor chains built on any LLM framework and seamlessly integrates with LangChain.
+
+### Deployment:
+- **[LangServe](https://python.langchain.com/docs/langserve)**: A library for deploying LangChain chains as REST APIs.
 
 ![Diagram outlining the hierarchical organization of the LangChain framework, displaying the interconnected parts across multiple layers.](docs/static/svg/langchain_stack.svg "LangChain Architecture Overview")
 
 ## 🧱 What can you build with LangChain?
-**❓ Retrieval augmented generation**
+
+**❓ Question answering with RAG**
 
 - [Documentation](https://python.langchain.com/docs/use_cases/question_answering/)
 - End-to-end Example: [Chat LangChain](https://chat.langchain.com) and [repo](https://github.com/langchain-ai/chat-langchain)
 
-**💬 Analyzing structured data**
+**🧱 Extracting structured output**
 
-- [Documentation](https://python.langchain.com/docs/use_cases/qa_structured/sql)
-- End-to-end Example: [SQL Llama2 Template](https://github.com/langchain-ai/langchain/tree/master/templates/sql-llama2)
+- [Documentation](https://python.langchain.com/docs/use_cases/extraction/)
+- End-to-end Example: [SQL Llama2 Template](https://github.com/langchain-ai/langchain-extract/)
 
 **🤖 Chatbots**
 
@@ -72,34 +78,51 @@ And much more! Head to the [Use cases](https://python.langchain.com/docs/use_cas
 
 ## 🚀 How does LangChain help?
 The main value props of the LangChain libraries are:
-1. **Components**: composable tools and integrations for working with language models. Components are modular and easy-to-use, whether you are using the rest of the LangChain framework or not
+1. **Components**: composable building blocks, tools and integrations for working with language models. Components are modular and easy-to-use, whether you are using the rest of the LangChain framework or not
 2. **Off-the-shelf chains**: built-in assemblages of components for accomplishing higher-level tasks
 
 Off-the-shelf chains make it easy to get started. Components make it easy to customize existing chains and build new ones. 
 
+## LangChain Expression Language (LCEL)
+
+LCEL is the foundation of many of LangChain's components, and is a declarative way to compose chains. LCEL was designed from day 1 to support putting prototypes in production, with no code changes, from the simplest “prompt + LLM” chain to the most complex chains.
+
+- **[Overview](https://python.langchain.com/docs/expression_language/)**: LCEL and its benefits
+- **[Interface](https://python.langchain.com/docs/expression_language/interface)**: The standard interface for LCEL objects
+- **[Primitives](https://python.langchain.com/docs/expression_language/primitives)**: More on the primitives LCEL includes
+
+## Components
+
 Components fall into the following **modules**:
 
 **📃 Model I/O:**
 
-This includes prompt management, prompt optimization, a generic interface for all LLMs, and common utilities for working with LLMs.
+This includes [prompt management](https://python.langchain.com/docs/modules/model_io/prompts/), [prompt optimization](https://python.langchain.com/docs/modules/model_io/prompts/example_selectors/), a generic interface for [chat models](https://python.langchain.com/docs/modules/model_io/chat/) and [LLMs](https://python.langchain.com/docs/modules/model_io/llms/), and common utilities for working with [model outputs](https://python.langchain.com/docs/modules/model_io/output_parsers/).
 
 **📚 Retrieval:**
 
-Data Augmented Generation involves specific types of chains that first interact with an external data source to fetch data for use in the generation step. Examples include summarization of long pieces of text and question/answering over specific data sources.
+Retrieval Augmented Generation involves [loading data](https://python.langchain.com/docs/modules/data_connection/document_loaders/) from a variety of sources, [preparing it](https://python.langchain.com/docs/modules/data_connection/document_loaders/), [then retrieving it](https://python.langchain.com/docs/modules/data_connection/retrievers/) for use in the generation step.
 
 **🤖 Agents:**
 
-Agents involve an LLM making decisions about which Actions to take, taking that Action, seeing an Observation, and repeating that until done. LangChain provides a standard interface for agents, a selection of agents to choose from, and examples of end-to-end 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 done. LangChain provides a [standard interface for agents](https://python.langchain.com/docs/modules/agents/), a [selection of agents](https://python.langchain.com/docs/modules/agents/agent_types/) to choose from, and examples of end-to-end agents.
 
 ## 📖 Documentation
 
 Please see [here](https://python.langchain.com) for full documentation, which includes:
 
 - [Getting started](https://python.langchain.com/docs/get_started/introduction): installation, setting up the environment, simple examples
-- Overview of the [interfaces](https://python.langchain.com/docs/expression_language/), [modules](https://python.langchain.com/docs/modules/), and [integrations](https://python.langchain.com/docs/integrations/providers)
-- [Use case](https://python.langchain.com/docs/use_cases/qa_structured/sql) walkthroughs and best practice [guides](https://python.langchain.com/docs/guides/adapters/openai)
-- [LangSmith](https://python.langchain.com/docs/langsmith/), [LangServe](https://python.langchain.com/docs/langserve), and [LangChain Template](https://python.langchain.com/docs/templates/) overviews
-- [Reference](https://api.python.langchain.com): full API docs
+- [Use case](https://python.langchain.com/docs/use_cases/) walkthroughs and best practice [guides](https://python.langchain.com/docs/guides/)
+- Overviews of the [interfaces](https://python.langchain.com/docs/expression_language/), [components](https://python.langchain.com/docs/modules/), and [integrations](https://python.langchain.com/docs/integrations/providers)
+
+You can also check out the full [API Reference docs](https://api.python.langchain.com).
+
+## 🌐 Ecosystem
+
+- [🦜🛠️ LangSmith](https://python.langchain.com/docs/langsmith/): Tracing and evaluating your language model applications and intelligent agents to help you move from prototype to production.
+- [🦜🕸️ LangGraph](https://python.langchain.com/docs/langgraph): Creating stateful, multi-actor applications with LLMs, built on top of (and intended to be used with) LangChain primitives.
+- [🦜🏓 LangServe](https://python.langchain.com/docs/langserve): Deploying LangChain runnables and chains as REST APIs.
+  - [LangChain Templates](https://python.langchain.com/docs/templates/): Example applications hosted with LangServe.
 
 
 ## 💁 Contributing

SECURITY.md

@@ -1,6 +1,61 @@
 # Security Policy
 
-## Reporting a Vulnerability
+## Reporting OSS Vulnerabilities
 
-Please report security vulnerabilities by email to `security@langchain.dev`.
-This email is an alias to a subset of our maintainers, and will ensure the issue is promptly triaged and acted upon as needed.
+LangChain is partnered with [huntr by Protect AI](https://huntr.com/) to provide 
+a bounty program for our open source projects. 
+
+Please report security vulnerabilities associated with the LangChain 
+open source projects by visiting the following link:
+
+[https://huntr.com/bounties/disclose/](https://huntr.com/bounties/disclose/?target=https%3A%2F%2Fgithub.com%2Flangchain-ai%2Flangchain&validSearch=true)
+
+Before reporting a vulnerability, please review:
+
+1) In-Scope Targets and Out-of-Scope Targets below.
+2) The [langchain-ai/langchain](https://python.langchain.com/docs/contributing/repo_structure) monorepo structure.
+3) LangChain [security guidelines](https://python.langchain.com/docs/security) to
+   understand what we consider to be a security vulnerability vs. developer
+   responsibility.
+
+### In-Scope Targets
+
+The following packages and repositories are eligible for bug bounties:
+
+- langchain-core
+- langchain (see exceptions)
+- langchain-community (see exceptions)
+- langgraph
+- langserve
+
+### Out of Scope Targets
+
+All out of scope targets defined by huntr as well as:
+
+- **langchain-experimental**: This repository is for experimental code and is not
+  eligible for bug bounties, bug reports to it will be marked as interesting or waste of
+  time and published with no bounty attached.
+- **tools**: Tools in either langchain or langchain-community are not eligible for bug
+  bounties. This includes the following directories
+  - langchain/tools
+  - langchain-community/tools
+  - Please review our [security guidelines](https://python.langchain.com/docs/security)
+    for more details, but generally tools interact with the real world. Developers are
+    expected to understand the security implications of their code and are responsible
+    for the security of their tools.
+- Code documented with security notices. This will be decided done on a case by
+  case basis, but likely will not be eligible for a bounty as the code is already
+  documented with guidelines for developers that should be followed for making their
+  application secure.
+- Any LangSmith related repositories or APIs see below.
+
+## Reporting LangSmith Vulnerabilities
+
+Please report security vulnerabilities associated with LangSmith by email to `security@langchain.dev`.
+
+- LangSmith site: https://smith.langchain.com
+- SDK client: https://github.com/langchain-ai/langsmith-sdk
+
+### Other Security Concerns
+
+For any other security concerns, please contact us at `security@langchain.dev`.

cookbook/LLaMA2_sql_chat.ipynb

@@ -38,9 +38,9 @@
     "\n",
     "To run locally, we use Ollama.ai. \n",
     "\n",
-    "See [here](https://python.langchain.com/docs/integrations/chat/ollama) for details on installation and setup.\n",
+    "See [here](/docs/integrations/chat/ollama) for details on installation and setup.\n",
     "\n",
-    "Also, see [here](https://python.langchain.com/docs/guides/local_llms) for our full guide on local LLMs.\n",
+    "Also, see [here](/docs/guides/development/local_llms) for our full guide on local LLMs.\n",
     " \n",
     "To use an external API, which is not private, we can use Replicate."
    ]

cookbook/Semi_structured_multi_modal_RAG_LLaMA2.ipynb

@@ -191,15 +191,15 @@
    "source": [
     "## Multi-vector retriever\n",
     "\n",
-    "Use [multi-vector-retriever](https://python.langchain.com/docs/modules/data_connection/retrievers/multi_vector#summary).\n",
+    "Use [multi-vector-retriever](/docs/modules/data_connection/retrievers/multi_vector#summary).\n",
     "\n",
     "Summaries are used to retrieve raw tables and / or raw chunks of text.\n",
     "\n",
     "### Text and Table summaries\n",
     "\n",
-    "Here, we use ollama.ai to run LLaMA2 locally. \n",
+    "Here, we use Ollama to run LLaMA2 locally. \n",
     "\n",
-    "See details on installation [here](https://python.langchain.com/docs/guides/local_llms)."
+    "See details on installation [here](/docs/guides/development/local_llms)."
    ]
   },
   {

cookbook/autogpt/marathon_times.ipynb

@@ -40,7 +40,9 @@
     "import nest_asyncio\n",
     "import pandas as pd\n",
     "from langchain.docstore.document import Document\n",
-    "from langchain_community.agent_toolkits.pandas.base import create_pandas_dataframe_agent\n",
+    "from langchain_experimental.agents.agent_toolkits.pandas.base import (\n",
+    "    create_pandas_dataframe_agent,\n",
+    ")\n",
     "from langchain_experimental.autonomous_agents import AutoGPT\n",
     "from langchain_openai import ChatOpenAI\n",
     "\n",
@@ -57,7 +59,7 @@
    },
    "outputs": [],
    "source": [
-    "llm = ChatOpenAI(model_name=\"gpt-4\", temperature=1.0)"
+    "llm = ChatOpenAI(model=\"gpt-4\", temperature=1.0)"
    ]
   },
   {

cookbook/code-analysis-deeplake.ipynb

@@ -933,7 +933,7 @@
       "**Answer**: The LangChain class includes various types of retrievers such as:\n",
       "\n",
       "- ArxivRetriever\n",
-      "- AzureCognitiveSearchRetriever\n",
+      "- AzureAISearchRetriever\n",
       "- BM25Retriever\n",
       "- ChaindeskRetriever\n",
       "- ChatGPTPluginRetriever\n",
@@ -993,7 +993,7 @@
     {
      "data": {
       "text/plain": [
-       "{'question': 'LangChain possesses a variety of retrievers including:\\n\\n1. ArxivRetriever\\n2. AzureCognitiveSearchRetriever\\n3. BM25Retriever\\n4. ChaindeskRetriever\\n5. ChatGPTPluginRetriever\\n6. ContextualCompressionRetriever\\n7. DocArrayRetriever\\n8. ElasticSearchBM25Retriever\\n9. EnsembleRetriever\\n10. GoogleVertexAISearchRetriever\\n11. AmazonKendraRetriever\\n12. KNNRetriever\\n13. LlamaIndexGraphRetriever\\n14. LlamaIndexRetriever\\n15. MergerRetriever\\n16. MetalRetriever\\n17. MilvusRetriever\\n18. MultiQueryRetriever\\n19. ParentDocumentRetriever\\n20. PineconeHybridSearchRetriever\\n21. PubMedRetriever\\n22. RePhraseQueryRetriever\\n23. RemoteLangChainRetriever\\n24. SelfQueryRetriever\\n25. SVMRetriever\\n26. TFIDFRetriever\\n27. TimeWeightedVectorStoreRetriever\\n28. VespaRetriever\\n29. WeaviateHybridSearchRetriever\\n30. WebResearchRetriever\\n31. WikipediaRetriever\\n32. ZepRetriever\\n33. ZillizRetriever\\n\\nIt also includes self query translators like:\\n\\n1. ChromaTranslator\\n2. DeepLakeTranslator\\n3. MyScaleTranslator\\n4. PineconeTranslator\\n5. QdrantTranslator\\n6. WeaviateTranslator\\n\\nAnd remote retrievers like:\\n\\n1. RemoteLangChainRetriever'}"
+       "{'question': 'LangChain possesses a variety of retrievers including:\\n\\n1. ArxivRetriever\\n2. AzureAISearchRetriever\\n3. BM25Retriever\\n4. ChaindeskRetriever\\n5. ChatGPTPluginRetriever\\n6. ContextualCompressionRetriever\\n7. DocArrayRetriever\\n8. ElasticSearchBM25Retriever\\n9. EnsembleRetriever\\n10. GoogleVertexAISearchRetriever\\n11. AmazonKendraRetriever\\n12. KNNRetriever\\n13. LlamaIndexGraphRetriever\\n14. LlamaIndexRetriever\\n15. MergerRetriever\\n16. MetalRetriever\\n17. MilvusRetriever\\n18. MultiQueryRetriever\\n19. ParentDocumentRetriever\\n20. PineconeHybridSearchRetriever\\n21. PubMedRetriever\\n22. RePhraseQueryRetriever\\n23. RemoteLangChainRetriever\\n24. SelfQueryRetriever\\n25. SVMRetriever\\n26. TFIDFRetriever\\n27. TimeWeightedVectorStoreRetriever\\n28. VespaRetriever\\n29. WeaviateHybridSearchRetriever\\n30. WebResearchRetriever\\n31. WikipediaRetriever\\n32. ZepRetriever\\n33. ZillizRetriever\\n\\nIt also includes self query translators like:\\n\\n1. ChromaTranslator\\n2. DeepLakeTranslator\\n3. MyScaleTranslator\\n4. PineconeTranslator\\n5. QdrantTranslator\\n6. WeaviateTranslator\\n\\nAnd remote retrievers like:\\n\\n1. RemoteLangChainRetriever'}"
       ]
      },
      "execution_count": 31,
@@ -1117,7 +1117,7 @@
       "The LangChain class includes various types of retrievers such as:\n",
       "\n",
       "- ArxivRetriever\n",
-      "- AzureCognitiveSearchRetriever\n",
+      "- AzureAISearchRetriever\n",
       "- BM25Retriever\n",
       "- ChaindeskRetriever\n",
       "- ChatGPTPluginRetriever\n",

cookbook/elasticsearch_db_qa.ipynb

@@ -84,7 +84,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "llm = ChatOpenAI(model_name=\"gpt-4\", temperature=0)\n",
+    "llm = ChatOpenAI(model=\"gpt-4\", temperature=0)\n",
     "chain = ElasticsearchDatabaseChain.from_llm(llm=llm, database=db, verbose=True)"
    ]
   },

cookbook/fake_llm.ipynb

@@ -100,7 +100,7 @@
     }
    ],
    "source": [
-    "agent.run(\"whats 2 + 2\")"
+    "agent.invoke(\"whats 2 + 2\")"
    ]
   },
   {

cookbook/llm_symbolic_math.ipynb

@@ -45,7 +45,7 @@
     }
    ],
    "source": [
-    "llm_symbolic_math.run(\"What is the derivative of sin(x)*exp(x) with respect to x?\")"
+    "llm_symbolic_math.invoke(\"What is the derivative of sin(x)*exp(x) with respect to x?\")"
    ]
   },
   {
@@ -65,7 +65,7 @@
     }
    ],
    "source": [
-    "llm_symbolic_math.run(\n",
+    "llm_symbolic_math.invoke(\n",
     "    \"What is the integral of exp(x)*sin(x) + exp(x)*cos(x) with respect to x?\"\n",
     ")"
    ]
@@ -94,7 +94,7 @@
     }
    ],
    "source": [
-    "llm_symbolic_math.run('Solve the differential equation y\" - y = e^t')"
+    "llm_symbolic_math.invoke('Solve the differential equation y\" - y = e^t')"
    ]
   },
   {
@@ -114,7 +114,7 @@
     }
    ],
    "source": [
-    "llm_symbolic_math.run(\"What are the solutions to this equation y^3 + 1/3y?\")"
+    "llm_symbolic_math.invoke(\"What are the solutions to this equation y^3 + 1/3y?\")"
    ]
   },
   {
@@ -134,7 +134,7 @@
     }
    ],
    "source": [
-    "llm_symbolic_math.run(\"x = y + 5, y = z - 3, z = x * y. Solve for x, y, z\")"
+    "llm_symbolic_math.invoke(\"x = y + 5, y = z - 3, z = x * y. Solve for x, y, z\")"
    ]
   }
  ],

cookbook/mongodb-langchain-cache-memory.ipynb

@@ -0,0 +1,818 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "70b333e6",
+   "metadata": {},
+   "source": [
+    "[![View Article](https://img.shields.io/badge/View%20Article-blue)](https://www.mongodb.com/developer/products/atlas/advanced-rag-langchain-mongodb/)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d84a72ea",
+   "metadata": {},
+   "source": [
+    "# Adding Semantic Caching and Memory to your RAG Application using MongoDB and LangChain\n",
+    "\n",
+    "In this notebook, we will see how to use the new MongoDBCache and MongoDBChatMessageHistory in your RAG application.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "65527202",
+   "metadata": {},
+   "source": [
+    "## Step 1: Install required libraries\n",
+    "\n",
+    "- **datasets**: Python library to get access to datasets available on Hugging Face Hub\n",
+    "\n",
+    "- **langchain**: Python toolkit for LangChain\n",
+    "\n",
+    "- **langchain-mongodb**: Python package to use MongoDB as a vector store, semantic cache, chat history store etc. in LangChain\n",
+    "\n",
+    "- **langchain-openai**: Python package to use OpenAI models with LangChain\n",
+    "\n",
+    "- **pymongo**: Python toolkit for MongoDB\n",
+    "\n",
+    "- **pandas**: Python library for data analysis, exploration, and manipulation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "cbc22fa4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "! pip install -qU datasets langchain langchain-mongodb langchain-openai pymongo pandas"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "39c41e87",
+   "metadata": {},
+   "source": [
+    "## Step 2: Setup pre-requisites\n",
+    "\n",
+    "* Set the MongoDB connection string. Follow the steps [here](https://www.mongodb.com/docs/manual/reference/connection-string/) to get the connection string from the Atlas UI.\n",
+    "\n",
+    "* Set the OpenAI API key. Steps to obtain an API key as [here](https://help.openai.com/en/articles/4936850-where-do-i-find-my-openai-api-key)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "b56412ae",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import getpass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "16a20d7a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Enter your MongoDB connection string:········\n"
+     ]
+    }
+   ],
+   "source": [
+    "MONGODB_URI = getpass.getpass(\"Enter your MongoDB connection string:\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "978682d4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Enter your OpenAI API key:········\n"
+     ]
+    }
+   ],
+   "source": [
+    "OPENAI_API_KEY = getpass.getpass(\"Enter your OpenAI API key:\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "606081c5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "········\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Optional-- If you want to enable Langsmith -- good for debugging\n",
+    "import os\n",
+    "\n",
+    "os.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\n",
+    "os.environ[\"LANGCHAIN_API_KEY\"] = getpass.getpass()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f6b8302c",
+   "metadata": {},
+   "source": [
+    "## Step 3: Download the dataset\n",
+    "\n",
+    "We will be using MongoDB's [embedded_movies](https://huggingface.co/datasets/MongoDB/embedded_movies) dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "1a3433a6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "from datasets import load_dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "aee5311b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Ensure you have an HF_TOKEN in your development enviornment:\n",
+    "# access tokens can be created or copied from the Hugging Face platform (https://huggingface.co/docs/hub/en/security-tokens)\n",
+    "\n",
+    "# Load MongoDB's embedded_movies dataset from Hugging Face\n",
+    "# https://huggingface.co/datasets/MongoDB/airbnb_embeddings\n",
+    "\n",
+    "data = load_dataset(\"MongoDB/embedded_movies\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "1d630a26",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.DataFrame(data[\"train\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a1f94f43",
+   "metadata": {},
+   "source": [
+    "## Step 4: Data analysis\n",
+    "\n",
+    "Make sure length of the dataset is what we expect, drop Nones etc."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "b276df71",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>fullplot</th>\n",
+       "      <th>type</th>\n",
+       "      <th>plot_embedding</th>\n",
+       "      <th>num_mflix_comments</th>\n",
+       "      <th>runtime</th>\n",
+       "      <th>writers</th>\n",
+       "      <th>imdb</th>\n",
+       "      <th>countries</th>\n",
+       "      <th>rated</th>\n",
+       "      <th>plot</th>\n",
+       "      <th>title</th>\n",
+       "      <th>languages</th>\n",
+       "      <th>metacritic</th>\n",
+       "      <th>directors</th>\n",
+       "      <th>awards</th>\n",
+       "      <th>genres</th>\n",
+       "      <th>poster</th>\n",
+       "      <th>cast</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Young Pauline is left a lot of money when her ...</td>\n",
+       "      <td>movie</td>\n",
+       "      <td>[0.00072939653, -0.026834568, 0.013515796, -0....</td>\n",
+       "      <td>0</td>\n",
+       "      <td>199.0</td>\n",
+       "      <td>[Charles W. Goddard (screenplay), Basil Dickey...</td>\n",
+       "      <td>{'id': 4465, 'rating': 7.6, 'votes': 744}</td>\n",
+       "      <td>[USA]</td>\n",
+       "      <td>None</td>\n",
+       "      <td>Young Pauline is left a lot of money when her ...</td>\n",
+       "      <td>The Perils of Pauline</td>\n",
+       "      <td>[English]</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>[Louis J. Gasnier, Donald MacKenzie]</td>\n",
+       "      <td>{'nominations': 0, 'text': '1 win.', 'wins': 1}</td>\n",
+       "      <td>[Action]</td>\n",
+       "      <td>https://m.media-amazon.com/images/M/MV5BMzgxOD...</td>\n",
+       "      <td>[Pearl White, Crane Wilbur, Paul Panzer, Edwar...</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                            fullplot   type  \\\n",
+       "0  Young Pauline is left a lot of money when her ...  movie   \n",
+       "\n",
+       "                                      plot_embedding  num_mflix_comments  \\\n",
+       "0  [0.00072939653, -0.026834568, 0.013515796, -0....                   0   \n",
+       "\n",
+       "   runtime                                            writers  \\\n",
+       "0    199.0  [Charles W. Goddard (screenplay), Basil Dickey...   \n",
+       "\n",
+       "                                        imdb countries rated  \\\n",
+       "0  {'id': 4465, 'rating': 7.6, 'votes': 744}     [USA]  None   \n",
+       "\n",
+       "                                                plot                  title  \\\n",
+       "0  Young Pauline is left a lot of money when her ...  The Perils of Pauline   \n",
+       "\n",
+       "   languages  metacritic                             directors  \\\n",
+       "0  [English]         NaN  [Louis J. Gasnier, Donald MacKenzie]   \n",
+       "\n",
+       "                                            awards    genres  \\\n",
+       "0  {'nominations': 0, 'text': '1 win.', 'wins': 1}  [Action]   \n",
+       "\n",
+       "                                              poster  \\\n",
+       "0  https://m.media-amazon.com/images/M/MV5BMzgxOD...   \n",
+       "\n",
+       "                                                cast  \n",
+       "0  [Pearl White, Crane Wilbur, Paul Panzer, Edwar...  "
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Previewing the contents of the data\n",
+    "df.head(1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "22ab375d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Only keep records where the fullplot field is not null\n",
+    "df = df[df[\"fullplot\"].notna()]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "fceed99a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Renaming the embedding field to \"embedding\" -- required by LangChain\n",
+    "df.rename(columns={\"plot_embedding\": \"embedding\"}, inplace=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "aedec13a",
+   "metadata": {},
+   "source": [
+    "## Step 5: Create a simple RAG chain using MongoDB as the vector store"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "11d292f3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_mongodb import MongoDBAtlasVectorSearch\n",
+    "from pymongo import MongoClient\n",
+    "\n",
+    "# Initialize MongoDB python client\n",
+    "client = MongoClient(MONGODB_URI, appname=\"devrel.content.python\")\n",
+    "\n",
+    "DB_NAME = \"langchain_chatbot\"\n",
+    "COLLECTION_NAME = \"data\"\n",
+    "ATLAS_VECTOR_SEARCH_INDEX_NAME = \"vector_index\"\n",
+    "collection = client[DB_NAME][COLLECTION_NAME]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "d8292d53",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "DeleteResult({'n': 1000, 'electionId': ObjectId('7fffffff00000000000000f6'), 'opTime': {'ts': Timestamp(1710523288, 1033), 't': 246}, 'ok': 1.0, '$clusterTime': {'clusterTime': Timestamp(1710523288, 1042), 'signature': {'hash': b\"i\\xa8\\xe9'\\x1ed\\xf2u\\xf3L\\xff\\xb1\\xf5\\xbfA\\x90\\xabJ\\x12\\x83\", 'keyId': 7299545392000008318}}, 'operationTime': Timestamp(1710523288, 1033)}, acknowledged=True)"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Delete any existing records in the collection\n",
+    "collection.delete_many({})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "36c68914",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Data ingestion into MongoDB completed\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Data Ingestion\n",
+    "records = df.to_dict(\"records\")\n",
+    "collection.insert_many(records)\n",
+    "\n",
+    "print(\"Data ingestion into MongoDB completed\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "cbfca0b8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_openai import OpenAIEmbeddings\n",
+    "\n",
+    "# Using the text-embedding-ada-002 since that's what was used to create embeddings in the movies dataset\n",
+    "embeddings = OpenAIEmbeddings(\n",
+    "    openai_api_key=OPENAI_API_KEY, model=\"text-embedding-ada-002\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "798e176c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Vector Store Creation\n",
+    "vector_store = MongoDBAtlasVectorSearch.from_connection_string(\n",
+    "    connection_string=MONGODB_URI,\n",
+    "    namespace=DB_NAME + \".\" + COLLECTION_NAME,\n",
+    "    embedding=embeddings,\n",
+    "    index_name=ATLAS_VECTOR_SEARCH_INDEX_NAME,\n",
+    "    text_key=\"fullplot\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "id": "c71cd087",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Using the MongoDB vector store as a retriever in a RAG chain\n",
+    "retriever = vector_store.as_retriever(search_type=\"similarity\", search_kwargs={\"k\": 5})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "b6588cd3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.prompts import ChatPromptTemplate\n",
+    "from langchain_core.runnables import RunnablePassthrough\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "\n",
+    "# Generate context using the retriever, and pass the user question through\n",
+    "retrieve = {\n",
+    "    \"context\": retriever | (lambda docs: \"\\n\\n\".join([d.page_content for d in docs])),\n",
+    "    \"question\": RunnablePassthrough(),\n",
+    "}\n",
+    "template = \"\"\"Answer the question based only on the following context: \\\n",
+    "{context}\n",
+    "\n",
+    "Question: {question}\n",
+    "\"\"\"\n",
+    "# Defining the chat prompt\n",
+    "prompt = ChatPromptTemplate.from_template(template)\n",
+    "# Defining the model to be used for chat completion\n",
+    "model = ChatOpenAI(temperature=0, openai_api_key=OPENAI_API_KEY)\n",
+    "# Parse output as a string\n",
+    "parse_output = StrOutputParser()\n",
+    "\n",
+    "# Naive RAG chain\n",
+    "naive_rag_chain = retrieve | prompt | model | parse_output"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "aaae21f5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Once a Thief'"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "naive_rag_chain.invoke(\"What is the best movie to watch when sad?\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "75f929ef",
+   "metadata": {},
+   "source": [
+    "## Step 6: Create a RAG chain with chat history"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "94e7bd4a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.prompts import MessagesPlaceholder\n",
+    "from langchain_core.runnables.history import RunnableWithMessageHistory\n",
+    "from langchain_mongodb.chat_message_histories import MongoDBChatMessageHistory"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "5bb30860",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_session_history(session_id: str) -> MongoDBChatMessageHistory:\n",
+    "    return MongoDBChatMessageHistory(\n",
+    "        MONGODB_URI, session_id, database_name=DB_NAME, collection_name=\"history\"\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "id": "f51d0f35",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Given a follow-up question and history, create a standalone question\n",
+    "standalone_system_prompt = \"\"\"\n",
+    "Given a chat history and a follow-up question, rephrase the follow-up question to be a standalone question. \\\n",
+    "Do NOT answer the question, just reformulate it if needed, otherwise return it as is. \\\n",
+    "Only return the final standalone question. \\\n",
+    "\"\"\"\n",
+    "standalone_question_prompt = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        (\"system\", standalone_system_prompt),\n",
+    "        MessagesPlaceholder(variable_name=\"history\"),\n",
+    "        (\"human\", \"{question}\"),\n",
+    "    ]\n",
+    ")\n",
+    "\n",
+    "question_chain = standalone_question_prompt | model | parse_output"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "id": "f3ef3354",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Generate context by passing output of the question_chain i.e. the standalone question to the retriever\n",
+    "retriever_chain = RunnablePassthrough.assign(\n",
+    "    context=question_chain\n",
+    "    | retriever\n",
+    "    | (lambda docs: \"\\n\\n\".join([d.page_content for d in docs]))\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "id": "5afb7345",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create a prompt that includes the context, history and the follow-up question\n",
+    "rag_system_prompt = \"\"\"Answer the question based only on the following context: \\\n",
+    "{context}\n",
+    "\"\"\"\n",
+    "rag_prompt = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        (\"system\", rag_system_prompt),\n",
+    "        MessagesPlaceholder(variable_name=\"history\"),\n",
+    "        (\"human\", \"{question}\"),\n",
+    "    ]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "id": "f95f47d0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# RAG chain\n",
+    "rag_chain = retriever_chain | rag_prompt | model | parse_output"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "id": "9618d395",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'The best movie to watch when feeling down could be \"Last Action Hero.\" It\\'s a fun and action-packed film that blends reality and fantasy, offering an escape from the real world and providing an entertaining distraction.'"
+      ]
+     },
+     "execution_count": 57,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# RAG chain with history\n",
+    "with_message_history = RunnableWithMessageHistory(\n",
+    "    rag_chain,\n",
+    "    get_session_history,\n",
+    "    input_messages_key=\"question\",\n",
+    "    history_messages_key=\"history\",\n",
+    ")\n",
+    "with_message_history.invoke(\n",
+    "    {\"question\": \"What is the best movie to watch when sad?\"},\n",
+    "    {\"configurable\": {\"session_id\": \"1\"}},\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "id": "6e3080d1",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'I apologize for the confusion. Another movie that might lift your spirits when you\\'re feeling sad is \"Smilla\\'s Sense of Snow.\" It\\'s a mystery thriller that could engage your mind and distract you from your sadness with its intriguing plot and suspenseful storyline.'"
+      ]
+     },
+     "execution_count": 58,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "with_message_history.invoke(\n",
+    "    {\n",
+    "        \"question\": \"Hmmm..I don't want to watch that one. Can you suggest something else?\"\n",
+    "    },\n",
+    "    {\"configurable\": {\"session_id\": \"1\"}},\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "id": "daea2953",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'For a lighter movie option, you might enjoy \"Cousins.\" It\\'s a comedy film set in Barcelona with action and humor, offering a fun and entertaining escape from reality. The storyline is engaging and filled with comedic moments that could help lift your spirits.'"
+      ]
+     },
+     "execution_count": 59,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "with_message_history.invoke(\n",
+    "    {\"question\": \"How about something more light?\"},\n",
+    "    {\"configurable\": {\"session_id\": \"1\"}},\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0de23a88",
+   "metadata": {},
+   "source": [
+    "## Step 7: Get faster responses using Semantic Cache\n",
+    "\n",
+    "**NOTE:** Semantic cache only caches the input to the LLM. When using it in retrieval chains, remember that documents retrieved can change between runs resulting in cache misses for semantically similar queries."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "id": "5d6b6741",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.globals import set_llm_cache\n",
+    "from langchain_mongodb.cache import MongoDBAtlasSemanticCache\n",
+    "\n",
+    "set_llm_cache(\n",
+    "    MongoDBAtlasSemanticCache(\n",
+    "        connection_string=MONGODB_URI,\n",
+    "        embedding=embeddings,\n",
+    "        collection_name=\"semantic_cache\",\n",
+    "        database_name=DB_NAME,\n",
+    "        index_name=ATLAS_VECTOR_SEARCH_INDEX_NAME,\n",
+    "        wait_until_ready=True,  # Optional, waits until the cache is ready to be used\n",
+    "    )\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 62,
+   "id": "9825bc7b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 87.8 ms, sys: 670 µs, total: 88.5 ms\n",
+      "Wall time: 1.24 s\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'Once a Thief'"
+      ]
+     },
+     "execution_count": 62,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "naive_rag_chain.invoke(\"What is the best movie to watch when sad?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "id": "a5e518cf",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 43.5 ms, sys: 4.16 ms, total: 47.7 ms\n",
+      "Wall time: 255 ms\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'Once a Thief'"
+      ]
+     },
+     "execution_count": 63,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "naive_rag_chain.invoke(\"What is the best movie to watch when sad?\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 64,
+   "id": "3d3d3ad3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 115 ms, sys: 171 µs, total: 115 ms\n",
+      "Wall time: 1.38 s\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'I would recommend watching \"Last Action Hero\" when sad, as it is a fun and action-packed film that can help lift your spirits.'"
+      ]
+     },
+     "execution_count": 64,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "naive_rag_chain.invoke(\"Which movie do I watch when sad?\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "conda_pytorch_p310",
+   "language": "python",
+   "name": "conda_pytorch_p310"
+  },
+  "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
+}

cookbook/press_releases.ipynb

@@ -84,7 +84,7 @@
     "from langchain.retrievers import KayAiRetriever\n",
     "from langchain_openai import ChatOpenAI\n",
     "\n",
-    "model = ChatOpenAI(model_name=\"gpt-3.5-turbo\")\n",
+    "model = ChatOpenAI(model=\"gpt-3.5-turbo\")\n",
     "retriever = KayAiRetriever.create(\n",
     "    dataset_id=\"company\", data_types=[\"PressRelease\"], num_contexts=6\n",
     ")\n",

cookbook/retrieval_in_sql.ipynb

@@ -274,7 +274,7 @@
     "db = SQLDatabase.from_uri(\n",
     "    CONNECTION_STRING\n",
     ")  # We reconnect to db so the new columns are loaded as well.\n",
-    "llm = ChatOpenAI(model_name=\"gpt-4\", temperature=0)\n",
+    "llm = ChatOpenAI(model=\"gpt-4\", temperature=0)\n",
     "\n",
     "sql_query_chain = (\n",
     "    RunnablePassthrough.assign(schema=get_schema)\n",

cookbook/rewrite.ipynb

@@ -245,7 +245,7 @@
     "\n",
     "\n",
     "def _parse(text):\n",
-    "    return text.strip(\"**\")"
+    "    return text.strip('\"').strip(\"**\")"
    ]
   },
   {

cookbook/sales_agent_with_context.ipynb

@@ -1,28 +1,32 @@
 {
  "cells": [
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# SalesGPT - Your Context-Aware AI Sales Assistant With Knowledge Base\n",
+    "# SalesGPT - Context-Aware AI Sales Assistant With Knowledge Base and Ability Generate Stripe Payment Links\n",
     "\n",
-    "This notebook demonstrates an implementation of a **Context-Aware** AI Sales agent with a Product Knowledge Base. \n",
+    "This notebook demonstrates an implementation of a **Context-Aware** AI Sales agent with a Product Knowledge Base which can actually close sales. \n",
     "\n",
     "This notebook was originally published at [filipmichalsky/SalesGPT](https://github.com/filip-michalsky/SalesGPT) by [@FilipMichalsky](https://twitter.com/FilipMichalsky).\n",
     "\n",
     "SalesGPT is context-aware, which means it can understand what section of a sales conversation it is in and act accordingly.\n",
     " \n",
-    "As such, this agent can have a natural sales conversation with a prospect and behaves based on the conversation stage. Hence, this notebook demonstrates how we can use AI to automate sales development representatives activities, such as outbound sales calls. \n",
+    "As such, this agent can have a natural sales conversation with a prospect and behaves based on the conversation stage. Hence, this notebook demonstrates how we can use AI to automate sales development representatives activites, such as outbound sales calls. \n",
     "\n",
     "Additionally, the AI Sales agent has access to tools, which allow it to interact with other systems.\n",
     "\n",
     "Here, we show how the AI Sales Agent can use a **Product Knowledge Base** to speak about a particular's company offerings,\n",
     "hence increasing relevance and reducing hallucinations.\n",
     "\n",
-    "We leverage the [`langchain`](https://github.com/langchain-ai/langchain) library in this implementation, specifically [Custom Agent Configuration](https://langchain-langchain.vercel.app/docs/modules/agents/how_to/custom_agent_with_tool_retrieval) and are inspired by [BabyAGI](https://github.com/yoheinakajima/babyagi) architecture ."
+    "Furthermore, we show how our AI Sales Agent can **generate sales** by integration with the AI Agent Highway called [Mindware](https://www.mindware.co/). In practice, this allows the agent to autonomously generate a payment link for your customers **to pay for your products via Stripe**.\n",
+    "\n",
+    "We leverage the [`langchain`](https://github.com/hwchase17/langchain) library in this implementation, specifically [Custom Agent Configuration](https://langchain-langchain.vercel.app/docs/modules/agents/how_to/custom_agent_with_tool_retrieval) and are inspired by [BabyAGI](https://github.com/yoheinakajima/babyagi) architecture ."
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -38,9 +42,10 @@
     "import os\n",
     "import re\n",
     "\n",
-    "# import your OpenAI key\n",
-    "OPENAI_API_KEY = \"sk-xx\"\n",
-    "os.environ[\"OPENAI_API_KEY\"] = OPENAI_API_KEY\n",
+    "# make sure you have .env file saved locally with your API keys\n",
+    "from dotenv import load_dotenv\n",
+    "\n",
+    "load_dotenv()\n",
     "\n",
     "from typing import Any, Callable, Dict, List, Union\n",
     "\n",
@@ -49,27 +54,18 @@
     "from langchain.agents.conversational.prompt import FORMAT_INSTRUCTIONS\n",
     "from langchain.chains import LLMChain, RetrievalQA\n",
     "from langchain.chains.base import Chain\n",
+    "from langchain.llms import BaseLLM\n",
     "from langchain.prompts import PromptTemplate\n",
     "from langchain.prompts.base import StringPromptTemplate\n",
-    "from langchain_community.llms import BaseLLM\n",
-    "from langchain_community.vectorstores import Chroma\n",
-    "from langchain_core.agents import AgentAction, AgentFinish\n",
-    "from langchain_openai import ChatOpenAI, OpenAI, OpenAIEmbeddings\n",
-    "from langchain_text_splitters import CharacterTextSplitter\n",
+    "from langchain.schema import AgentAction, AgentFinish\n",
+    "from langchain.text_splitter import CharacterTextSplitter\n",
+    "from langchain.vectorstores import Chroma\n",
+    "from langchain_openai import ChatOpenAI, OpenAIEmbeddings\n",
     "from pydantic import BaseModel, Field"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# install additional dependencies\n",
-    "# ! pip install chromadb openai tiktoken"
-   ]
-  },
-  {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -77,19 +73,21 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "1. Seed the SalesGPT agent\n",
     "2. Run Sales Agent to decide what to do:\n",
     "\n",
-    "    a) Use a tool, such as look up Product Information in a Knowledge Base\n",
+    "    a) Use a tool, such as look up Product Information in a Knowledge Base or Generate a Payment Link\n",
     "    \n",
     "    b) Output a response to a user \n",
     "3. Run Sales Stage Recognition Agent to recognize which stage is the sales agent at and adjust their behaviour accordingly."
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -98,15 +96,17 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Architecture diagram\n",
     "\n",
-    "<img src=\"https://singularity-assets-public.s3.amazonaws.com/new_flow.png\"  width=\"800\" height=\"440\"/>\n"
+    "<img src=\"https://demo-bucket-45.s3.amazonaws.com/new_flow2.png\"  width=\"800\" height=\"440\">\n"
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -131,7 +131,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -149,7 +149,7 @@
     "            {conversation_history}\n",
     "            ===\n",
     "\n",
-    "            Now determine what should be the next immediate conversation stage for the agent in the sales conversation by selecting only from the following options:\n",
+    "            Now determine what should be the next immediate conversation stage for the agent in the sales conversation by selecting ony from the following options:\n",
     "            1. Introduction: Start the conversation by introducing yourself and your company. Be polite and respectful while keeping the tone of the conversation professional.\n",
     "            2. Qualification: Qualify the prospect by confirming if they are the right person to talk to regarding your product/service. Ensure that they have the authority to make purchasing decisions.\n",
     "            3. Value proposition: Briefly explain how your product/service can benefit the prospect. Focus on the unique selling points and value proposition of your product/service that sets it apart from competitors.\n",
@@ -171,7 +171,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -223,7 +223,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -240,13 +240,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
     "# test the intermediate chains\n",
     "verbose = True\n",
-    "llm = ChatOpenAI(temperature=0.9)\n",
+    "llm = ChatOpenAI(\n",
+    "    model=\"gpt-4-turbo-preview\",\n",
+    "    temperature=0.9,\n",
+    "    openai_api_key=os.getenv(\"OPENAI_API_KEY\"),\n",
+    ")\n",
     "\n",
     "stage_analyzer_chain = StageAnalyzerChain.from_llm(llm, verbose=verbose)\n",
     "\n",
@@ -257,7 +261,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
@@ -276,7 +280,7 @@
       "            \n",
       "            ===\n",
       "\n",
-      "            Now determine what should be the next immediate conversation stage for the agent in the sales conversation by selecting only from the following options:\n",
+      "            Now determine what should be the next immediate conversation stage for the agent in the sales conversation by selecting ony from the following options:\n",
       "            1. Introduction: Start the conversation by introducing yourself and your company. Be polite and respectful while keeping the tone of the conversation professional.\n",
       "            2. Qualification: Qualify the prospect by confirming if they are the right person to talk to regarding your product/service. Ensure that they have the authority to make purchasing decisions.\n",
       "            3. Value proposition: Briefly explain how your product/service can benefit the prospect. Focus on the unique selling points and value proposition of your product/service that sets it apart from competitors.\n",
@@ -296,21 +300,21 @@
     {
      "data": {
       "text/plain": [
-       "'1'"
+       "{'conversation_history': '', 'text': '1'}"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "stage_analyzer_chain.run(conversation_history=\"\")"
+    "stage_analyzer_chain.invoke({\"conversation_history\": \"\"})"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -352,32 +356,44 @@
     {
      "data": {
       "text/plain": [
-       "\"I'm doing great, thank you for asking! As a Business Development Representative at Sleep Haven, I wanted to reach out to see if you are looking to achieve a better night's sleep. We provide premium mattresses that offer the most comfortable and supportive sleeping experience possible. Are you interested in exploring our sleep solutions? <END_OF_TURN>\""
+       "{'salesperson_name': 'Ted Lasso',\n",
+       " 'salesperson_role': 'Business Development Representative',\n",
+       " 'company_name': 'Sleep Haven',\n",
+       " 'company_business': 'Sleep Haven is a premium mattress company that provides customers with the most comfortable and supportive sleeping experience possible. We offer a range of high-quality mattresses, pillows, and bedding accessories that are designed to meet the unique needs of our customers.',\n",
+       " 'company_values': \"Our mission at Sleep Haven is to help people achieve a better night's sleep by providing them with the best possible sleep solutions. We believe that quality sleep is essential to overall health and well-being, and we are committed to helping our customers achieve optimal sleep by offering exceptional products and customer service.\",\n",
+       " 'conversation_purpose': 'find out whether they are looking to achieve better sleep via buying a premier mattress.',\n",
+       " 'conversation_history': 'Hello, this is Ted Lasso from Sleep Haven. How are you doing today? <END_OF_TURN>\\nUser: I am well, howe are you?<END_OF_TURN>',\n",
+       " 'conversation_type': 'call',\n",
+       " 'conversation_stage': 'Introduction: Start the conversation by introducing yourself and your company. Be polite and respectful while keeping the tone of the conversation professional. Your greeting should be welcoming. Always clarify in your greeting the reason why you are contacting the prospect.',\n",
+       " 'text': \"I'm doing well, thank you for asking. The reason I'm calling is to discuss how Sleep Haven can help enhance your sleep quality with our premium mattresses. Are you currently looking for ways to achieve a better night's sleep? <END_OF_TURN>\"}"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "sales_conversation_utterance_chain.run(\n",
-    "    salesperson_name=\"Ted Lasso\",\n",
-    "    salesperson_role=\"Business Development Representative\",\n",
-    "    company_name=\"Sleep Haven\",\n",
-    "    company_business=\"Sleep Haven is a premium mattress company that provides customers with the most comfortable and supportive sleeping experience possible. We offer a range of high-quality mattresses, pillows, and bedding accessories that are designed to meet the unique needs of our customers.\",\n",
-    "    company_values=\"Our mission at Sleep Haven is to help people achieve a better night's sleep by providing them with the best possible sleep solutions. We believe that quality sleep is essential to overall health and well-being, and we are committed to helping our customers achieve optimal sleep by offering exceptional products and customer service.\",\n",
-    "    conversation_purpose=\"find out whether they are looking to achieve better sleep via buying a premier mattress.\",\n",
-    "    conversation_history=\"Hello, this is Ted Lasso from Sleep Haven. How are you doing today? <END_OF_TURN>\\nUser: I am well, howe are you?<END_OF_TURN>\",\n",
-    "    conversation_type=\"call\",\n",
-    "    conversation_stage=conversation_stages.get(\n",
-    "        \"1\",\n",
-    "        \"Introduction: Start the conversation by introducing yourself and your company. Be polite and respectful while keeping the tone of the conversation professional.\",\n",
-    "    ),\n",
+    "sales_conversation_utterance_chain.invoke(\n",
+    "    {\n",
+    "        \"salesperson_name\": \"Ted Lasso\",\n",
+    "        \"salesperson_role\": \"Business Development Representative\",\n",
+    "        \"company_name\": \"Sleep Haven\",\n",
+    "        \"company_business\": \"Sleep Haven is a premium mattress company that provides customers with the most comfortable and supportive sleeping experience possible. We offer a range of high-quality mattresses, pillows, and bedding accessories that are designed to meet the unique needs of our customers.\",\n",
+    "        \"company_values\": \"Our mission at Sleep Haven is to help people achieve a better night's sleep by providing them with the best possible sleep solutions. We believe that quality sleep is essential to overall health and well-being, and we are committed to helping our customers achieve optimal sleep by offering exceptional products and customer service.\",\n",
+    "        \"conversation_purpose\": \"find out whether they are looking to achieve better sleep via buying a premier mattress.\",\n",
+    "        \"conversation_history\": \"Hello, this is Ted Lasso from Sleep Haven. How are you doing today? <END_OF_TURN>\\nUser: I am well, howe are you?<END_OF_TURN>\",\n",
+    "        \"conversation_type\": \"call\",\n",
+    "        \"conversation_stage\": conversation_stages.get(\n",
+    "            \"1\",\n",
+    "            \"Introduction: Start the conversation by introducing yourself and your company. Be polite and respectful while keeping the tone of the conversation professional.\",\n",
+    "        ),\n",
+    "    }\n",
     ")"
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -385,6 +401,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -395,7 +412,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -429,7 +446,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -445,7 +462,7 @@
     "    text_splitter = CharacterTextSplitter(chunk_size=10, chunk_overlap=0)\n",
     "    texts = text_splitter.split_text(product_catalog)\n",
     "\n",
-    "    llm = OpenAI(temperature=0)\n",
+    "    llm = ChatOpenAI(temperature=0)\n",
     "    embeddings = OpenAIEmbeddings()\n",
     "    docsearch = Chroma.from_texts(\n",
     "        texts, embeddings, collection_name=\"product-knowledge-base\"\n",
@@ -454,29 +471,12 @@
     "    knowledge_base = RetrievalQA.from_chain_type(\n",
     "        llm=llm, chain_type=\"stuff\", retriever=docsearch.as_retriever()\n",
     "    )\n",
-    "    return knowledge_base\n",
-    "\n",
-    "\n",
-    "def get_tools(product_catalog):\n",
-    "    # query to get_tools can be used to be embedded and relevant tools found\n",
-    "    # see here: https://langchain-langchain.vercel.app/docs/use_cases/agents/custom_agent_with_plugin_retrieval#tool-retriever\n",
-    "\n",
-    "    # we only use one tool for now, but this is highly extensible!\n",
-    "    knowledge_base = setup_knowledge_base(product_catalog)\n",
-    "    tools = [\n",
-    "        Tool(\n",
-    "            name=\"ProductSearch\",\n",
-    "            func=knowledge_base.run,\n",
-    "            description=\"useful for when you need to answer questions about product information\",\n",
-    "        )\n",
-    "    ]\n",
-    "\n",
-    "    return tools"
+    "    return knowledge_base"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
@@ -485,16 +485,18 @@
      "text": [
       "Created a chunk of size 940, which is longer than the specified 10\n",
       "Created a chunk of size 844, which is longer than the specified 10\n",
-      "Created a chunk of size 837, which is longer than the specified 10\n"
+      "Created a chunk of size 837, which is longer than the specified 10\n",
+      "/Users/filipmichalsky/Odyssey/sales_bot/SalesGPT/env/lib/python3.10/site-packages/langchain_core/_api/deprecation.py:117: LangChainDeprecationWarning: The function `run` was deprecated in LangChain 0.1.0 and will be removed in 0.2.0. Use invoke instead.\n",
+      "  warn_deprecated(\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "' We have four products available: the Classic Harmony Spring Mattress, the Plush Serenity Bamboo Mattress, the Luxury Cloud-Comfort Memory Foam Mattress, and the EcoGreen Hybrid Latex Mattress. Each product is available in different sizes, with the Classic Harmony Spring Mattress available in Queen and King sizes, the Plush Serenity Bamboo Mattress available in King size, the Luxury Cloud-Comfort Memory Foam Mattress available in Twin, Queen, and King sizes, and the EcoGreen Hybrid Latex Mattress available in Twin and Full sizes.'"
+       "'The Sleep Haven products available are:\\n\\n1. Luxury Cloud-Comfort Memory Foam Mattress\\n2. Classic Harmony Spring Mattress\\n3. EcoGreen Hybrid Latex Mattress\\n4. Plush Serenity Bamboo Mattress\\n\\nEach product has its unique features and price point.'"
       ]
      },
-     "execution_count": 11,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -508,12 +510,199 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Set up the SalesGPT Controller with the Sales Agent and Stage Analyzer and a Knowledge Base"
+    "### Payment gateway"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In order to set up your AI agent to use a payment gateway to generate payment links for your users you need two things:\n",
+    "\n",
+    "1. Sign up for a Stripe account and obtain a STRIPE API KEY\n",
+    "2. Create products you would like to sell in the Stripe UI. Then follow out example of `example_product_price_id_mapping.json`\n",
+    "to feed the product name to price_id mapping which allows you to generate the payment links."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "\n",
+    "from litellm import completion\n",
+    "\n",
+    "# set GPT model env variable\n",
+    "os.environ[\"GPT_MODEL\"] = \"gpt-4-turbo-preview\"\n",
+    "\n",
+    "product_price_id_mapping = {\n",
+    "    \"ai-consulting-services\": \"price_1Ow8ofB795AYY8p1goWGZi6m\",\n",
+    "    \"Luxury Cloud-Comfort Memory Foam Mattress\": \"price_1Owv99B795AYY8p1mjtbKyxP\",\n",
+    "    \"Classic Harmony Spring Mattress\": \"price_1Owv9qB795AYY8p1tPcxCM6T\",\n",
+    "    \"EcoGreen Hybrid Latex Mattress\": \"price_1OwvLDB795AYY8p1YBAMBcbi\",\n",
+    "    \"Plush Serenity Bamboo Mattress\": \"price_1OwvMQB795AYY8p1hJN2uS3S\",\n",
+    "}\n",
+    "with open(\"example_product_price_id_mapping.json\", \"w\") as f:\n",
+    "    json.dump(product_price_id_mapping, f)\n",
+    "\n",
+    "\n",
+    "def get_product_id_from_query(query, product_price_id_mapping_path):\n",
+    "    # Load product_price_id_mapping from a JSON file\n",
+    "    with open(product_price_id_mapping_path, \"r\") as f:\n",
+    "        product_price_id_mapping = json.load(f)\n",
+    "\n",
+    "    # Serialize the product_price_id_mapping to a JSON string for inclusion in the prompt\n",
+    "    product_price_id_mapping_json_str = json.dumps(product_price_id_mapping)\n",
+    "\n",
+    "    # Dynamically create the enum list from product_price_id_mapping keys\n",
+    "    enum_list = list(product_price_id_mapping.values()) + [\n",
+    "        \"No relevant product id found\"\n",
+    "    ]\n",
+    "    enum_list_str = json.dumps(enum_list)\n",
+    "\n",
+    "    prompt = f\"\"\"\n",
+    "    You are an expert data scientist and you are working on a project to recommend products to customers based on their needs.\n",
+    "    Given the following query:\n",
+    "    {query}\n",
+    "    and the following product price id mapping:\n",
+    "    {product_price_id_mapping_json_str}\n",
+    "    return the price id that is most relevant to the query.\n",
+    "    ONLY return the price id, no other text. If no relevant price id is found, return 'No relevant price id found'.\n",
+    "    Your output will follow this schema:\n",
+    "    {{\n",
+    "    \"$schema\": \"http://json-schema.org/draft-07/schema#\",\n",
+    "    \"title\": \"Price ID Response\",\n",
+    "    \"type\": \"object\",\n",
+    "    \"properties\": {{\n",
+    "        \"price_id\": {{\n",
+    "        \"type\": \"string\",\n",
+    "        \"enum\": {enum_list_str}\n",
+    "        }}\n",
+    "    }},\n",
+    "    \"required\": [\"price_id\"]\n",
+    "    }}\n",
+    "    Return a valid directly parsable json, dont return in it within a code snippet or add any kind of explanation!!\n",
+    "    \"\"\"\n",
+    "    prompt += \"{\"\n",
+    "    response = completion(\n",
+    "        model=os.getenv(\"GPT_MODEL\", \"gpt-3.5-turbo-1106\"),\n",
+    "        messages=[{\"content\": prompt, \"role\": \"user\"}],\n",
+    "        max_tokens=1000,\n",
+    "        temperature=0,\n",
+    "    )\n",
+    "\n",
+    "    product_id = response.choices[0].message.content.strip()\n",
+    "    return product_id"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "\n",
+    "import requests\n",
+    "\n",
+    "\n",
+    "def generate_stripe_payment_link(query: str) -> str:\n",
+    "    \"\"\"Generate a stripe payment link for a customer based on a single query string.\"\"\"\n",
+    "\n",
+    "    # example testing payment gateway url\n",
+    "    PAYMENT_GATEWAY_URL = os.getenv(\n",
+    "        \"PAYMENT_GATEWAY_URL\", \"https://agent-payments-gateway.vercel.app/payment\"\n",
+    "    )\n",
+    "    PRODUCT_PRICE_MAPPING = \"example_product_price_id_mapping.json\"\n",
+    "\n",
+    "    # use LLM to get the price_id from query\n",
+    "    price_id = get_product_id_from_query(query, PRODUCT_PRICE_MAPPING)\n",
+    "    price_id = json.loads(price_id)\n",
+    "    payload = json.dumps(\n",
+    "        {\"prompt\": query, **price_id, \"stripe_key\": os.getenv(\"STRIPE_API_KEY\")}\n",
+    "    )\n",
+    "    headers = {\n",
+    "        \"Content-Type\": \"application/json\",\n",
+    "    }\n",
+    "\n",
+    "    response = requests.request(\n",
+    "        \"POST\", PAYMENT_GATEWAY_URL, headers=headers, data=payload\n",
+    "    )\n",
+    "    return response.text"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'{\"response\":\"https://buy.stripe.com/test_6oEbLS8JB1F9bv229d\"}'"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "generate_stripe_payment_link(\n",
+    "    query=\"Please generate a payment link for John Doe to buy two mattresses - the Classic Harmony Spring Mattress\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup agent tools"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_tools(product_catalog):\n",
+    "    # query to get_tools can be used to be embedded and relevant tools found\n",
+    "    # see here: https://langchain-langchain.vercel.app/docs/use_cases/agents/custom_agent_with_plugin_retrieval#tool-retriever\n",
+    "\n",
+    "    # we only use one tool for now, but this is highly extensible!\n",
+    "    knowledge_base = setup_knowledge_base(product_catalog)\n",
+    "    tools = [\n",
+    "        Tool(\n",
+    "            name=\"ProductSearch\",\n",
+    "            func=knowledge_base.run,\n",
+    "            description=\"useful for when you need to answer questions about product information or services offered, availability and their costs.\",\n",
+    "        ),\n",
+    "        Tool(\n",
+    "            name=\"GeneratePaymentLink\",\n",
+    "            func=generate_stripe_payment_link,\n",
+    "            description=\"useful to close a transaction with a customer. You need to include product name and quantity and customer name in the query input.\",\n",
+    "        ),\n",
+    "    ]\n",
+    "\n",
+    "    return tools"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Set up the SalesGPT Controller with the Sales Agent and Stage Analyzer\n",
+    "\n",
+    "#### The Agent has access to a Knowledge Base and can autonomously sell your products via Stripe"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -563,19 +752,11 @@
     "            print(\"TEXT\")\n",
     "            print(text)\n",
     "            print(\"-------\")\n",
-    "        if f\"{self.ai_prefix}:\" in text:\n",
-    "            return AgentFinish(\n",
-    "                {\"output\": text.split(f\"{self.ai_prefix}:\")[-1].strip()}, text\n",
-    "            )\n",
     "        regex = r\"Action: (.*?)[\\n]*Action Input: (.*)\"\n",
     "        match = re.search(regex, text)\n",
     "        if not match:\n",
-    "            ## TODO - this is not entirely reliable, sometimes results in an error.\n",
     "            return AgentFinish(\n",
-    "                {\n",
-    "                    \"output\": \"I apologize, I was unable to find the answer to your question. Is there anything else I can help with?\"\n",
-    "                },\n",
-    "                text,\n",
+    "                {\"output\": text.split(f\"{self.ai_prefix}:\")[-1].strip()}, text\n",
     "            )\n",
     "            # raise OutputParserException(f\"Could not parse LLM output: `{text}`\")\n",
     "        action = match.group(1)\n",
@@ -589,7 +770,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -647,18 +828,18 @@
     "Previous conversation history:\n",
     "{conversation_history}\n",
     "\n",
-    "{salesperson_name}:\n",
+    "Thought:\n",
     "{agent_scratchpad}\n",
     "\"\"\""
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 20,
    "metadata": {},
    "outputs": [],
    "source": [
-    "class SalesGPT(Chain, BaseModel):\n",
+    "class SalesGPT(Chain):\n",
     "    \"\"\"Controller model for the Sales Agent.\"\"\"\n",
     "\n",
     "    conversation_history: List[str] = []\n",
@@ -804,7 +985,9 @@
     "\n",
     "            # WARNING: this output parser is NOT reliable yet\n",
     "            ## It makes assumptions about output from LLM which can break and throw an error\n",
-    "            output_parser = SalesConvoOutputParser(ai_prefix=kwargs[\"salesperson_name\"])\n",
+    "            output_parser = SalesConvoOutputParser(\n",
+    "                ai_prefix=kwargs[\"salesperson_name\"], verbose=verbose\n",
+    "            )\n",
     "\n",
     "            sales_agent_with_tools = LLMSingleActionAgent(\n",
     "                llm_chain=llm_chain,\n",
@@ -828,6 +1011,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -835,6 +1019,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -843,7 +1028,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -880,6 +1065,7 @@
    ]
   },
   {
+   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -888,7 +1074,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [
     {
@@ -897,7 +1083,9 @@
      "text": [
       "Created a chunk of size 940, which is longer than the specified 10\n",
       "Created a chunk of size 844, which is longer than the specified 10\n",
-      "Created a chunk of size 837, which is longer than the specified 10\n"
+      "Created a chunk of size 837, which is longer than the specified 10\n",
+      "/Users/filipmichalsky/Odyssey/sales_bot/SalesGPT/env/lib/python3.10/site-packages/langchain_core/_api/deprecation.py:117: LangChainDeprecationWarning: The class `langchain.agents.agent.LLMSingleActionAgent` was deprecated in langchain 0.1.0 and will be removed in 0.2.0. Use Use new agent constructor methods like create_react_agent, create_json_agent, create_structured_chat_agent, etc. instead.\n",
+      "  warn_deprecated(\n"
      ]
     }
    ],
@@ -907,7 +1095,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -917,7 +1105,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 22,
    "metadata": {},
    "outputs": [
     {
@@ -934,14 +1122,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 23,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Ted Lasso:  Hello, this is Ted Lasso from Sleep Haven. How are you doing today?\n"
+      "Ted Lasso:  Good day! This is Ted Lasso from Sleep Haven. How are you doing today?\n"
      ]
     }
    ],
@@ -951,18 +1139,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [],
    "source": [
     "sales_agent.human_step(\n",
-    "    \"I am well, how are you? I would like to learn more about your mattresses.\"\n",
+    "    \"I am well, how are you? I would like to learn more about your services.\"\n",
     ")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 25,
    "metadata": {},
    "outputs": [
     {
@@ -977,92 +1165,32 @@
     "sales_agent.determine_conversation_stage()"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Ted Lasso:  I'm glad to hear that you're doing well! As for our mattresses, at Sleep Haven, we provide customers with the most comfortable and supportive sleeping experience possible. Our high-quality mattresses are designed to meet the unique needs of our customers. Can I ask what specifically you'd like to learn more about? \n"
-     ]
-    }
-   ],
-   "source": [
-    "sales_agent.step()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "sales_agent.human_step(\"Yes, what materials are you mattresses made from?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Conversation Stage: Needs analysis: Ask open-ended questions to uncover the prospect's needs and pain points. Listen carefully to their responses and take notes.\n"
-     ]
-    }
-   ],
-   "source": [
-    "sales_agent.determine_conversation_stage()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Ted Lasso:  Our mattresses are made from a variety of materials, depending on the model. We have the EcoGreen Hybrid Latex Mattress, which is made from 100% natural latex harvested from eco-friendly plantations. The Plush Serenity Bamboo Mattress features a layer of plush, adaptive foam and a base of high-resilience support foam, with a bamboo-infused top layer. The Luxury Cloud-Comfort Memory Foam Mattress has an innovative, temperature-sensitive memory foam layer and a high-density foam base with cooling gel-infused particles. Finally, the Classic Harmony Spring Mattress has a robust inner spring construction and layers of plush padding, with a quilted top layer and a natural cotton cover. Is there anything specific you'd like to know about these materials?\n"
-     ]
-    }
-   ],
-   "source": [
-    "sales_agent.step()"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 26,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Ted Lasso:  I'm doing great, thank you for asking! I'm glad to hear you're interested. Sleep Haven is a premium mattress company, and we're all about offering the best sleep solutions, including top-notch mattresses, pillows, and bedding accessories. Our mission is to help you achieve a better night's sleep. May I know if you're looking to enhance your sleep experience with a new mattress or bedding accessories? \n"
+     ]
+    }
+   ],
    "source": [
-    "sales_agent.human_step(\n",
-    "    \"Yes, I am looking for a queen sized mattress. Do you have any mattresses in queen size?\"\n",
-    ")"
+    "sales_agent.step()"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 27,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Conversation Stage: Needs analysis: Ask open-ended questions to uncover the prospect's needs and pain points. Listen carefully to their responses and take notes.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "sales_agent.determine_conversation_stage()"
+    "sales_agent.human_step(\n",
+    "    \"Yes, I would like to improve my sleep. Can you tell me more about your products?\"\n",
+    ")"
    ]
   },
   {
@@ -1074,7 +1202,24 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Ted Lasso:  Yes, we do have queen-sized mattresses available. We offer the Luxury Cloud-Comfort Memory Foam Mattress and the Classic Harmony Spring Mattress in queen size. Both mattresses provide exceptional comfort and support. Is there anything specific you would like to know about these options?\n"
+      "Conversation Stage: Needs analysis: Ask open-ended questions to uncover the prospect's needs and pain points. Listen carefully to their responses and take notes.\n"
+     ]
+    }
+   ],
+   "source": [
+    "sales_agent.determine_conversation_stage()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Ted Lasso:  Absolutely, I'd be happy to share more about our products. At Sleep Haven, we offer a variety of high-quality mattresses designed to cater to different sleeping preferences and needs. Whether you're looking for memory foam's comfort, the support of hybrid mattresses, or the breathability of natural latex, we have options for everyone. Our pillows and bedding accessories are similarly curated to enhance your sleep quality. Every product is built with the aim of helping you achieve the restful night's sleep you deserve. What specific features are you looking for in a mattress? \n"
      ]
     }
    ],
@@ -1084,16 +1229,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 31,
    "metadata": {},
    "outputs": [],
    "source": [
-    "sales_agent.human_step(\"Yea, compare and contrast those two options, please.\")"
+    "sales_agent.human_step(\"What mattresses do you have and how much do they cost?\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 32,
    "metadata": {},
    "outputs": [
     {
@@ -1110,14 +1255,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 33,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Ted Lasso:  The Luxury Cloud-Comfort Memory Foam Mattress is priced at $999 and is available in Twin, Queen, and King sizes. It features an innovative, temperature-sensitive memory foam layer and a high-density foam base. On the other hand, the Classic Harmony Spring Mattress is priced at $1,299 and is available in Queen and King sizes. It features a robust inner spring construction and layers of plush padding. Both mattresses provide exceptional comfort and support, but the Classic Harmony Spring Mattress may be a better option if you prefer the traditional feel of an inner spring mattress. Do you have any other questions about these options?\n"
+      "Ted Lasso:  We offer two primary types of mattresses at Sleep Haven. The first is our Luxury Cloud-Comfort Memory Foam Mattress, which is priced at $999 and comes in Twin, Queen, and King sizes. The second is our Classic Harmony Spring Mattress, priced at $1,299, available in Queen and King sizes. Both are designed to provide exceptional comfort and support for a better night's sleep. Which type of mattress would you be interested in learning more about? \n"
      ]
     }
    ],
@@ -1127,14 +1272,66 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 34,
    "metadata": {},
    "outputs": [],
    "source": [
     "sales_agent.human_step(\n",
-    "    \"Great, thanks, that's it. I will talk to my wife and call back if she is onboard. Have a good day!\"\n",
+    "    \"Okay.I would like to order two Memory Foam mattresses in Twin size please.\"\n",
     ")"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Conversation Stage: Close: Ask for the sale by proposing a next step. This could be a demo, a trial or a meeting with decision-makers. Ensure to summarize what has been discussed and reiterate the benefits.\n"
+     ]
+    }
+   ],
+   "source": [
+    "sales_agent.determine_conversation_stage()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Ted Lasso:  Fantastic choice! You're on your way to a better night's sleep with our Luxury Cloud-Comfort Memory Foam Mattresses. I've generated a payment link for two Twin size mattresses for you. Here is the link to complete your purchase: https://buy.stripe.com/test_6oEg28e3V97BdDabJn. Is there anything else I can assist you with today? \n"
+     ]
+    }
+   ],
+   "source": [
+    "sales_agent.step()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sales_agent.human_step(\n",
+    "    \"Great, thanks! I will discuss with my wife and will buy it if she is onboard. Have a good day!\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
@@ -1153,9 +1350,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.3"
+   "version": "3.10.9"
   }
  },
  "nbformat": 4,
- "nbformat_minor": 2
+ "nbformat_minor": 4
 }

cookbook/sharedmemory_for_tools.ipynb

@@ -22,7 +22,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.agents import AgentExecutor, Tool, ZeroShotAgent\n",
+    "from langchain import hub\n",
+    "from langchain.agents import AgentExecutor, Tool, ZeroShotAgent, create_react_agent\n",
     "from langchain.chains import LLMChain\n",
     "from langchain.memory import ConversationBufferMemory, ReadOnlySharedMemory\n",
     "from langchain.prompts import PromptTemplate\n",
@@ -84,19 +85,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "prefix = \"\"\"Have a conversation with a human, answering the following questions as best you can. You have access to the following tools:\"\"\"\n",
-    "suffix = \"\"\"Begin!\"\n",
-    "\n",
-    "{chat_history}\n",
-    "Question: {input}\n",
-    "{agent_scratchpad}\"\"\"\n",
-    "\n",
-    "prompt = ZeroShotAgent.create_prompt(\n",
-    "    tools,\n",
-    "    prefix=prefix,\n",
-    "    suffix=suffix,\n",
-    "    input_variables=[\"input\", \"chat_history\", \"agent_scratchpad\"],\n",
-    ")"
+    "prompt = hub.pull(\"hwchase17/react\")"
    ]
   },
   {
@@ -114,16 +103,14 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "llm_chain = LLMChain(llm=OpenAI(temperature=0), prompt=prompt)\n",
-    "agent = ZeroShotAgent(llm_chain=llm_chain, tools=tools, verbose=True)\n",
-    "agent_chain = AgentExecutor.from_agent_and_tools(\n",
-    "    agent=agent, tools=tools, verbose=True, memory=memory\n",
-    ")"
+    "model = OpenAI()\n",
+    "agent = create_react_agent(model, tools, prompt)\n",
+    "agent_executor = AgentExecutor(agent=agent, tools=tools, memory=memory)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 36,
    "id": "ca4bc1fb",
    "metadata": {},
    "outputs": [
@@ -133,15 +120,15 @@
      "text": [
       "\n",
       "\n",
-      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3mThought: I should research ChatGPT to answer this question.\n",
+      "\u001B[1m> Entering new AgentExecutor chain...\u001B[0m\n",
+      "\u001B[32;1m\u001B[1;3mThought: I should research ChatGPT to answer this question.\n",
       "Action: Search\n",
-      "Action Input: \"ChatGPT\"\u001b[0m\n",
-      "Observation: \u001b[36;1m\u001b[1;3mNov 30, 2022 ... We've trained a model called ChatGPT which interacts in a conversational way. The dialogue format makes it possible for ChatGPT to answer ... ChatGPT is an artificial intelligence chatbot developed by OpenAI and launched in November 2022. It is built on top of OpenAI's GPT-3 family of large ... ChatGPT. We've trained a model called ChatGPT which interacts in a conversational way. The dialogue format makes it possible for ChatGPT to answer ... Feb 2, 2023 ... ChatGPT, the popular chatbot from OpenAI, is estimated to have reached 100 million monthly active users in January, just two months after ... 2 days ago ... ChatGPT recently launched a new version of its own plagiarism detection tool, with hopes that it will squelch some of the criticism around how ... An API for accessing new AI models developed by OpenAI. Feb 19, 2023 ... ChatGPT is an AI chatbot system that OpenAI released in November to show off and test what a very large, powerful AI system can accomplish. You ... ChatGPT is fine-tuned from GPT-3.5, a language model trained to produce text. ChatGPT was optimized for dialogue by using Reinforcement Learning with Human ... 3 days ago ... Visual ChatGPT connects ChatGPT and a series of Visual Foundation Models to enable sending and receiving images during chatting. Dec 1, 2022 ... ChatGPT is a natural language processing tool driven by AI technology that allows you to have human-like conversations and much more with a ...\u001b[0m\n",
-      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer.\n",
-      "Final Answer: ChatGPT is an artificial intelligence chatbot developed by OpenAI and launched in November 2022. It is built on top of OpenAI's GPT-3 family of large language models and is optimized for dialogue by using Reinforcement Learning with Human-in-the-Loop. It is also capable of sending and receiving images during chatting.\u001b[0m\n",
+      "Action Input: \"ChatGPT\"\u001B[0m\n",
+      "Observation: \u001B[36;1m\u001B[1;3mNov 30, 2022 ... We've trained a model called ChatGPT which interacts in a conversational way. The dialogue format makes it possible for ChatGPT to answer ... ChatGPT is an artificial intelligence chatbot developed by OpenAI and launched in November 2022. It is built on top of OpenAI's GPT-3 family of large ... ChatGPT. We've trained a model called ChatGPT which interacts in a conversational way. The dialogue format makes it possible for ChatGPT to answer ... Feb 2, 2023 ... ChatGPT, the popular chatbot from OpenAI, is estimated to have reached 100 million monthly active users in January, just two months after ... 2 days ago ... ChatGPT recently launched a new version of its own plagiarism detection tool, with hopes that it will squelch some of the criticism around how ... An API for accessing new AI models developed by OpenAI. Feb 19, 2023 ... ChatGPT is an AI chatbot system that OpenAI released in November to show off and test what a very large, powerful AI system can accomplish. You ... ChatGPT is fine-tuned from GPT-3.5, a language model trained to produce text. ChatGPT was optimized for dialogue by using Reinforcement Learning with Human ... 3 days ago ... Visual ChatGPT connects ChatGPT and a series of Visual Foundation Models to enable sending and receiving images during chatting. Dec 1, 2022 ... ChatGPT is a natural language processing tool driven by AI technology that allows you to have human-like conversations and much more with a ...\u001B[0m\n",
+      "Thought:\u001B[32;1m\u001B[1;3m I now know the final answer.\n",
+      "Final Answer: ChatGPT is an artificial intelligence chatbot developed by OpenAI and launched in November 2022. It is built on top of OpenAI's GPT-3 family of large language models and is optimized for dialogue by using Reinforcement Learning with Human-in-the-Loop. It is also capable of sending and receiving images during chatting.\u001B[0m\n",
       "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
+      "\u001B[1m> Finished chain.\u001B[0m\n"
      ]
     },
     {
@@ -153,10 +140,40 @@
      "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
+    },
+    {
+     "ename": "KeyboardInterrupt",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
+      "\u001B[0;31mKeyboardInterrupt\u001B[0m                         Traceback (most recent call last)",
+      "Cell \u001B[0;32mIn[36], line 1\u001B[0m\n\u001B[0;32m----> 1\u001B[0m \u001B[43magent_executor\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43minvoke\u001B[49m\u001B[43m(\u001B[49m\u001B[43m{\u001B[49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[38;5;124;43minput\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[43m:\u001B[49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[38;5;124;43mWhat is ChatGPT?\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[43m}\u001B[49m\u001B[43m)\u001B[49m\n",
+      "File \u001B[0;32m~/code/langchain/libs/langchain/langchain/chains/base.py:163\u001B[0m, in \u001B[0;36mChain.invoke\u001B[0;34m(self, input, config, **kwargs)\u001B[0m\n\u001B[1;32m    161\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m \u001B[38;5;167;01mBaseException\u001B[39;00m \u001B[38;5;28;01mas\u001B[39;00m e:\n\u001B[1;32m    162\u001B[0m     run_manager\u001B[38;5;241m.\u001B[39mon_chain_error(e)\n\u001B[0;32m--> 163\u001B[0m     \u001B[38;5;28;01mraise\u001B[39;00m e\n\u001B[1;32m    164\u001B[0m run_manager\u001B[38;5;241m.\u001B[39mon_chain_end(outputs)\n\u001B[1;32m    166\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m include_run_info:\n",
+      "File \u001B[0;32m~/code/langchain/libs/langchain/langchain/chains/base.py:153\u001B[0m, in \u001B[0;36mChain.invoke\u001B[0;34m(self, input, config, **kwargs)\u001B[0m\n\u001B[1;32m    150\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[1;32m    151\u001B[0m     \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_validate_inputs(inputs)\n\u001B[1;32m    152\u001B[0m     outputs \u001B[38;5;241m=\u001B[39m (\n\u001B[0;32m--> 153\u001B[0m         \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_call\u001B[49m\u001B[43m(\u001B[49m\u001B[43minputs\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mrun_manager\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mrun_manager\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m    154\u001B[0m         \u001B[38;5;28;01mif\u001B[39;00m new_arg_supported\n\u001B[1;32m    155\u001B[0m         \u001B[38;5;28;01melse\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_call(inputs)\n\u001B[1;32m    156\u001B[0m     )\n\u001B[1;32m    158\u001B[0m     final_outputs: Dict[\u001B[38;5;28mstr\u001B[39m, Any] \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mprep_outputs(\n\u001B[1;32m    159\u001B[0m         inputs, outputs, return_only_outputs\n\u001B[1;32m    160\u001B[0m     )\n\u001B[1;32m    161\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m \u001B[38;5;167;01mBaseException\u001B[39;00m \u001B[38;5;28;01mas\u001B[39;00m e:\n",
+      "File \u001B[0;32m~/code/langchain/libs/langchain/langchain/agents/agent.py:1432\u001B[0m, in \u001B[0;36mAgentExecutor._call\u001B[0;34m(self, inputs, run_manager)\u001B[0m\n\u001B[1;32m   1430\u001B[0m \u001B[38;5;66;03m# We now enter the agent loop (until it returns something).\u001B[39;00m\n\u001B[1;32m   1431\u001B[0m \u001B[38;5;28;01mwhile\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_should_continue(iterations, time_elapsed):\n\u001B[0;32m-> 1432\u001B[0m     next_step_output \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_take_next_step\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m   1433\u001B[0m \u001B[43m        \u001B[49m\u001B[43mname_to_tool_map\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m   1434\u001B[0m \u001B[43m        \u001B[49m\u001B[43mcolor_mapping\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m   1435\u001B[0m \u001B[43m        \u001B[49m\u001B[43minputs\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m   1436\u001B[0m \u001B[43m        \u001B[49m\u001B[43mintermediate_steps\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m   1437\u001B[0m \u001B[43m        \u001B[49m\u001B[43mrun_manager\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mrun_manager\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m   1438\u001B[0m \u001B[43m    \u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m   1439\u001B[0m     \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(next_step_output, AgentFinish):\n\u001B[1;32m   1440\u001B[0m         \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_return(\n\u001B[1;32m   1441\u001B[0m             next_step_output, intermediate_steps, run_manager\u001B[38;5;241m=\u001B[39mrun_manager\n\u001B[1;32m   1442\u001B[0m         )\n",
+      "File \u001B[0;32m~/code/langchain/libs/langchain/langchain/agents/agent.py:1138\u001B[0m, in \u001B[0;36mAgentExecutor._take_next_step\u001B[0;34m(self, name_to_tool_map, color_mapping, inputs, intermediate_steps, run_manager)\u001B[0m\n\u001B[1;32m   1129\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21m_take_next_step\u001B[39m(\n\u001B[1;32m   1130\u001B[0m     \u001B[38;5;28mself\u001B[39m,\n\u001B[1;32m   1131\u001B[0m     name_to_tool_map: Dict[\u001B[38;5;28mstr\u001B[39m, BaseTool],\n\u001B[0;32m   (...)\u001B[0m\n\u001B[1;32m   1135\u001B[0m     run_manager: Optional[CallbackManagerForChainRun] \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;01mNone\u001B[39;00m,\n\u001B[1;32m   1136\u001B[0m ) \u001B[38;5;241m-\u001B[39m\u001B[38;5;241m>\u001B[39m Union[AgentFinish, List[Tuple[AgentAction, \u001B[38;5;28mstr\u001B[39m]]]:\n\u001B[1;32m   1137\u001B[0m     \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_consume_next_step(\n\u001B[0;32m-> 1138\u001B[0m         [\n\u001B[1;32m   1139\u001B[0m             a\n\u001B[1;32m   1140\u001B[0m             \u001B[38;5;28;01mfor\u001B[39;00m a \u001B[38;5;129;01min\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_iter_next_step(\n\u001B[1;32m   1141\u001B[0m                 name_to_tool_map,\n\u001B[1;32m   1142\u001B[0m                 color_mapping,\n\u001B[1;32m   1143\u001B[0m                 inputs,\n\u001B[1;32m   1144\u001B[0m                 intermediate_steps,\n\u001B[1;32m   1145\u001B[0m                 run_manager,\n\u001B[1;32m   1146\u001B[0m             )\n\u001B[1;32m   1147\u001B[0m         ]\n\u001B[1;32m   1148\u001B[0m     )\n",
+      "File \u001B[0;32m~/code/langchain/libs/langchain/langchain/agents/agent.py:1138\u001B[0m, in \u001B[0;36m<listcomp>\u001B[0;34m(.0)\u001B[0m\n\u001B[1;32m   1129\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21m_take_next_step\u001B[39m(\n\u001B[1;32m   1130\u001B[0m     \u001B[38;5;28mself\u001B[39m,\n\u001B[1;32m   1131\u001B[0m     name_to_tool_map: Dict[\u001B[38;5;28mstr\u001B[39m, BaseTool],\n\u001B[0;32m   (...)\u001B[0m\n\u001B[1;32m   1135\u001B[0m     run_manager: Optional[CallbackManagerForChainRun] \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;01mNone\u001B[39;00m,\n\u001B[1;32m   1136\u001B[0m ) \u001B[38;5;241m-\u001B[39m\u001B[38;5;241m>\u001B[39m Union[AgentFinish, List[Tuple[AgentAction, \u001B[38;5;28mstr\u001B[39m]]]:\n\u001B[1;32m   1137\u001B[0m     \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_consume_next_step(\n\u001B[0;32m-> 1138\u001B[0m         [\n\u001B[1;32m   1139\u001B[0m             a\n\u001B[1;32m   1140\u001B[0m             \u001B[38;5;28;01mfor\u001B[39;00m a \u001B[38;5;129;01min\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_iter_next_step(\n\u001B[1;32m   1141\u001B[0m                 name_to_tool_map,\n\u001B[1;32m   1142\u001B[0m                 color_mapping,\n\u001B[1;32m   1143\u001B[0m                 inputs,\n\u001B[1;32m   1144\u001B[0m                 intermediate_steps,\n\u001B[1;32m   1145\u001B[0m                 run_manager,\n\u001B[1;32m   1146\u001B[0m             )\n\u001B[1;32m   1147\u001B[0m         ]\n\u001B[1;32m   1148\u001B[0m     )\n",
+      "File \u001B[0;32m~/code/langchain/libs/langchain/langchain/agents/agent.py:1223\u001B[0m, in \u001B[0;36mAgentExecutor._iter_next_step\u001B[0;34m(self, name_to_tool_map, color_mapping, inputs, intermediate_steps, run_manager)\u001B[0m\n\u001B[1;32m   1221\u001B[0m     \u001B[38;5;28;01myield\u001B[39;00m agent_action\n\u001B[1;32m   1222\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m agent_action \u001B[38;5;129;01min\u001B[39;00m actions:\n\u001B[0;32m-> 1223\u001B[0m     \u001B[38;5;28;01myield\u001B[39;00m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_perform_agent_action\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m   1224\u001B[0m \u001B[43m        \u001B[49m\u001B[43mname_to_tool_map\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mcolor_mapping\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43magent_action\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mrun_manager\u001B[49m\n\u001B[1;32m   1225\u001B[0m \u001B[43m    \u001B[49m\u001B[43m)\u001B[49m\n",
+      "File \u001B[0;32m~/code/langchain/libs/langchain/langchain/agents/agent.py:1245\u001B[0m, in \u001B[0;36mAgentExecutor._perform_agent_action\u001B[0;34m(self, name_to_tool_map, color_mapping, agent_action, run_manager)\u001B[0m\n\u001B[1;32m   1243\u001B[0m         tool_run_kwargs[\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mllm_prefix\u001B[39m\u001B[38;5;124m\"\u001B[39m] \u001B[38;5;241m=\u001B[39m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m   1244\u001B[0m     \u001B[38;5;66;03m# We then call the tool on the tool input to get an observation\u001B[39;00m\n\u001B[0;32m-> 1245\u001B[0m     observation \u001B[38;5;241m=\u001B[39m \u001B[43mtool\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mrun\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m   1246\u001B[0m \u001B[43m        \u001B[49m\u001B[43magent_action\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mtool_input\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m   1247\u001B[0m \u001B[43m        \u001B[49m\u001B[43mverbose\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mverbose\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m   1248\u001B[0m \u001B[43m        \u001B[49m\u001B[43mcolor\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mcolor\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m   1249\u001B[0m \u001B[43m        \u001B[49m\u001B[43mcallbacks\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mrun_manager\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mget_child\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;28;43;01mif\u001B[39;49;00m\u001B[43m \u001B[49m\u001B[43mrun_manager\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;28;43;01melse\u001B[39;49;00m\u001B[43m \u001B[49m\u001B[38;5;28;43;01mNone\u001B[39;49;00m\u001B[43m,\u001B[49m\n\u001B[1;32m   1250\u001B[0m \u001B[43m        \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mtool_run_kwargs\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m   1251\u001B[0m \u001B[43m    \u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m   1252\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[1;32m   1253\u001B[0m     tool_run_kwargs \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39magent\u001B[38;5;241m.\u001B[39mtool_run_logging_kwargs()\n",
+      "File \u001B[0;32m~/code/langchain/libs/core/langchain_core/tools.py:422\u001B[0m, in \u001B[0;36mBaseTool.run\u001B[0;34m(self, tool_input, verbose, start_color, color, callbacks, tags, metadata, run_name, run_id, **kwargs)\u001B[0m\n\u001B[1;32m    420\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m (\u001B[38;5;167;01mException\u001B[39;00m, \u001B[38;5;167;01mKeyboardInterrupt\u001B[39;00m) \u001B[38;5;28;01mas\u001B[39;00m e:\n\u001B[1;32m    421\u001B[0m     run_manager\u001B[38;5;241m.\u001B[39mon_tool_error(e)\n\u001B[0;32m--> 422\u001B[0m     \u001B[38;5;28;01mraise\u001B[39;00m e\n\u001B[1;32m    423\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[1;32m    424\u001B[0m     run_manager\u001B[38;5;241m.\u001B[39mon_tool_end(observation, color\u001B[38;5;241m=\u001B[39mcolor, name\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mname, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs)\n",
+      "File \u001B[0;32m~/code/langchain/libs/core/langchain_core/tools.py:381\u001B[0m, in \u001B[0;36mBaseTool.run\u001B[0;34m(self, tool_input, verbose, start_color, color, callbacks, tags, metadata, run_name, run_id, **kwargs)\u001B[0m\n\u001B[1;32m    378\u001B[0m     parsed_input \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_parse_input(tool_input)\n\u001B[1;32m    379\u001B[0m     tool_args, tool_kwargs \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_to_args_and_kwargs(parsed_input)\n\u001B[1;32m    380\u001B[0m     observation \u001B[38;5;241m=\u001B[39m (\n\u001B[0;32m--> 381\u001B[0m         \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_run\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mtool_args\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mrun_manager\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mrun_manager\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mtool_kwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m    382\u001B[0m         \u001B[38;5;28;01mif\u001B[39;00m new_arg_supported\n\u001B[1;32m    383\u001B[0m         \u001B[38;5;28;01melse\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_run(\u001B[38;5;241m*\u001B[39mtool_args, \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mtool_kwargs)\n\u001B[1;32m    384\u001B[0m     )\n\u001B[1;32m    385\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m ValidationError \u001B[38;5;28;01mas\u001B[39;00m e:\n\u001B[1;32m    386\u001B[0m     \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mhandle_validation_error:\n",
+      "File \u001B[0;32m~/code/langchain/libs/core/langchain_core/tools.py:588\u001B[0m, in \u001B[0;36mTool._run\u001B[0;34m(self, run_manager, *args, **kwargs)\u001B[0m\n\u001B[1;32m    579\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mfunc:\n\u001B[1;32m    580\u001B[0m     new_argument_supported \u001B[38;5;241m=\u001B[39m signature(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mfunc)\u001B[38;5;241m.\u001B[39mparameters\u001B[38;5;241m.\u001B[39mget(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mcallbacks\u001B[39m\u001B[38;5;124m\"\u001B[39m)\n\u001B[1;32m    581\u001B[0m     \u001B[38;5;28;01mreturn\u001B[39;00m (\n\u001B[1;32m    582\u001B[0m         \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mfunc(\n\u001B[1;32m    583\u001B[0m             \u001B[38;5;241m*\u001B[39margs,\n\u001B[1;32m    584\u001B[0m             callbacks\u001B[38;5;241m=\u001B[39mrun_manager\u001B[38;5;241m.\u001B[39mget_child() \u001B[38;5;28;01mif\u001B[39;00m run_manager \u001B[38;5;28;01melse\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m,\n\u001B[1;32m    585\u001B[0m             \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39mkwargs,\n\u001B[1;32m    586\u001B[0m         )\n\u001B[1;32m    587\u001B[0m         \u001B[38;5;28;01mif\u001B[39;00m new_argument_supported\n\u001B[0;32m--> 588\u001B[0m         \u001B[38;5;28;01melse\u001B[39;00m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mfunc\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43margs\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m    589\u001B[0m     )\n\u001B[1;32m    590\u001B[0m \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mNotImplementedError\u001B[39;00m(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mTool does not support sync\u001B[39m\u001B[38;5;124m\"\u001B[39m)\n",
+      "File \u001B[0;32m~/code/langchain/libs/community/langchain_community/utilities/google_search.py:94\u001B[0m, in \u001B[0;36mGoogleSearchAPIWrapper.run\u001B[0;34m(self, query)\u001B[0m\n\u001B[1;32m     92\u001B[0m \u001B[38;5;250m\u001B[39m\u001B[38;5;124;03m\"\"\"Run query through GoogleSearch and parse result.\"\"\"\u001B[39;00m\n\u001B[1;32m     93\u001B[0m snippets \u001B[38;5;241m=\u001B[39m []\n\u001B[0;32m---> 94\u001B[0m results \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_google_search_results\u001B[49m\u001B[43m(\u001B[49m\u001B[43mquery\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mnum\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mk\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m     95\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28mlen\u001B[39m(results) \u001B[38;5;241m==\u001B[39m \u001B[38;5;241m0\u001B[39m:\n\u001B[1;32m     96\u001B[0m     \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mNo good Google Search Result was found\u001B[39m\u001B[38;5;124m\"\u001B[39m\n",
+      "File \u001B[0;32m~/code/langchain/libs/community/langchain_community/utilities/google_search.py:62\u001B[0m, in \u001B[0;36mGoogleSearchAPIWrapper._google_search_results\u001B[0;34m(self, search_term, **kwargs)\u001B[0m\n\u001B[1;32m     60\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39msiterestrict:\n\u001B[1;32m     61\u001B[0m     cse \u001B[38;5;241m=\u001B[39m cse\u001B[38;5;241m.\u001B[39msiterestrict()\n\u001B[0;32m---> 62\u001B[0m res \u001B[38;5;241m=\u001B[39m \u001B[43mcse\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mlist\u001B[49m\u001B[43m(\u001B[49m\u001B[43mq\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43msearch_term\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mcx\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mgoogle_cse_id\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mexecute\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m     63\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m res\u001B[38;5;241m.\u001B[39mget(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mitems\u001B[39m\u001B[38;5;124m\"\u001B[39m, [])\n",
+      "File \u001B[0;32m~/code/langchain/.venv/lib/python3.10/site-packages/googleapiclient/_helpers.py:130\u001B[0m, in \u001B[0;36mpositional.<locals>.positional_decorator.<locals>.positional_wrapper\u001B[0;34m(*args, **kwargs)\u001B[0m\n\u001B[1;32m    128\u001B[0m     \u001B[38;5;28;01melif\u001B[39;00m positional_parameters_enforcement \u001B[38;5;241m==\u001B[39m POSITIONAL_WARNING:\n\u001B[1;32m    129\u001B[0m         logger\u001B[38;5;241m.\u001B[39mwarning(message)\n\u001B[0;32m--> 130\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43mwrapped\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43margs\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n",
+      "File \u001B[0;32m~/code/langchain/.venv/lib/python3.10/site-packages/googleapiclient/http.py:923\u001B[0m, in \u001B[0;36mHttpRequest.execute\u001B[0;34m(self, http, num_retries)\u001B[0m\n\u001B[1;32m    920\u001B[0m     \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mheaders[\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mcontent-length\u001B[39m\u001B[38;5;124m\"\u001B[39m] \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mstr\u001B[39m(\u001B[38;5;28mlen\u001B[39m(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mbody))\n\u001B[1;32m    922\u001B[0m \u001B[38;5;66;03m# Handle retries for server-side errors.\u001B[39;00m\n\u001B[0;32m--> 923\u001B[0m resp, content \u001B[38;5;241m=\u001B[39m \u001B[43m_retry_request\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m    924\u001B[0m \u001B[43m    \u001B[49m\u001B[43mhttp\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m    925\u001B[0m \u001B[43m    \u001B[49m\u001B[43mnum_retries\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m    926\u001B[0m \u001B[43m    \u001B[49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[38;5;124;43mrequest\u001B[39;49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[43m,\u001B[49m\n\u001B[1;32m    927\u001B[0m \u001B[43m    \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_sleep\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m    928\u001B[0m \u001B[43m    \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_rand\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m    929\u001B[0m \u001B[43m    \u001B[49m\u001B[38;5;28;43mstr\u001B[39;49m\u001B[43m(\u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43muri\u001B[49m\u001B[43m)\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m    930\u001B[0m \u001B[43m    \u001B[49m\u001B[43mmethod\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mstr\u001B[39;49m\u001B[43m(\u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mmethod\u001B[49m\u001B[43m)\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m    931\u001B[0m \u001B[43m    \u001B[49m\u001B[43mbody\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mbody\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m    932\u001B[0m \u001B[43m    \u001B[49m\u001B[43mheaders\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mheaders\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m    933\u001B[0m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m    935\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m callback \u001B[38;5;129;01min\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mresponse_callbacks:\n\u001B[1;32m    936\u001B[0m     callback(resp)\n",
+      "File \u001B[0;32m~/code/langchain/.venv/lib/python3.10/site-packages/googleapiclient/http.py:191\u001B[0m, in \u001B[0;36m_retry_request\u001B[0;34m(http, num_retries, req_type, sleep, rand, uri, method, *args, **kwargs)\u001B[0m\n\u001B[1;32m    189\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[1;32m    190\u001B[0m     exception \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;01mNone\u001B[39;00m\n\u001B[0;32m--> 191\u001B[0m     resp, content \u001B[38;5;241m=\u001B[39m \u001B[43mhttp\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mrequest\u001B[49m\u001B[43m(\u001B[49m\u001B[43muri\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mmethod\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43margs\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m    192\u001B[0m \u001B[38;5;66;03m# Retry on SSL errors and socket timeout errors.\u001B[39;00m\n\u001B[1;32m    193\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m _ssl_SSLError \u001B[38;5;28;01mas\u001B[39;00m ssl_error:\n",
+      "File \u001B[0;32m~/code/langchain/.venv/lib/python3.10/site-packages/httplib2/__init__.py:1724\u001B[0m, in \u001B[0;36mHttp.request\u001B[0;34m(self, uri, method, body, headers, redirections, connection_type)\u001B[0m\n\u001B[1;32m   1722\u001B[0m             content \u001B[38;5;241m=\u001B[39m \u001B[38;5;124mb\u001B[39m\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m   1723\u001B[0m         \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[0;32m-> 1724\u001B[0m             (response, content) \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_request\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m   1725\u001B[0m \u001B[43m                \u001B[49m\u001B[43mconn\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mauthority\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43muri\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mrequest_uri\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mmethod\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mbody\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mheaders\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mredirections\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mcachekey\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m   1726\u001B[0m \u001B[43m            \u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m   1727\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m \u001B[38;5;167;01mException\u001B[39;00m \u001B[38;5;28;01mas\u001B[39;00m e:\n\u001B[1;32m   1728\u001B[0m     is_timeout \u001B[38;5;241m=\u001B[39m \u001B[38;5;28misinstance\u001B[39m(e, socket\u001B[38;5;241m.\u001B[39mtimeout)\n",
+      "File \u001B[0;32m~/code/langchain/.venv/lib/python3.10/site-packages/httplib2/__init__.py:1444\u001B[0m, in \u001B[0;36mHttp._request\u001B[0;34m(self, conn, host, absolute_uri, request_uri, method, body, headers, redirections, cachekey)\u001B[0m\n\u001B[1;32m   1441\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m auth:\n\u001B[1;32m   1442\u001B[0m     auth\u001B[38;5;241m.\u001B[39mrequest(method, request_uri, headers, body)\n\u001B[0;32m-> 1444\u001B[0m (response, content) \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_conn_request\u001B[49m\u001B[43m(\u001B[49m\u001B[43mconn\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mrequest_uri\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mmethod\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mbody\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mheaders\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m   1446\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m auth:\n\u001B[1;32m   1447\u001B[0m     \u001B[38;5;28;01mif\u001B[39;00m auth\u001B[38;5;241m.\u001B[39mresponse(response, body):\n",
+      "File \u001B[0;32m~/code/langchain/.venv/lib/python3.10/site-packages/httplib2/__init__.py:1366\u001B[0m, in \u001B[0;36mHttp._conn_request\u001B[0;34m(self, conn, request_uri, method, body, headers)\u001B[0m\n\u001B[1;32m   1364\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[1;32m   1365\u001B[0m     \u001B[38;5;28;01mif\u001B[39;00m conn\u001B[38;5;241m.\u001B[39msock \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[0;32m-> 1366\u001B[0m         \u001B[43mconn\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mconnect\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m   1367\u001B[0m     conn\u001B[38;5;241m.\u001B[39mrequest(method, request_uri, body, headers)\n\u001B[1;32m   1368\u001B[0m \u001B[38;5;28;01mexcept\u001B[39;00m socket\u001B[38;5;241m.\u001B[39mtimeout:\n",
+      "File \u001B[0;32m~/code/langchain/.venv/lib/python3.10/site-packages/httplib2/__init__.py:1156\u001B[0m, in \u001B[0;36mHTTPSConnectionWithTimeout.connect\u001B[0;34m(self)\u001B[0m\n\u001B[1;32m   1154\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m has_timeout(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mtimeout):\n\u001B[1;32m   1155\u001B[0m     sock\u001B[38;5;241m.\u001B[39msettimeout(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mtimeout)\n\u001B[0;32m-> 1156\u001B[0m \u001B[43msock\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mconnect\u001B[49m\u001B[43m(\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mhost\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mport\u001B[49m\u001B[43m)\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m   1158\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39msock \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_context\u001B[38;5;241m.\u001B[39mwrap_socket(sock, server_hostname\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mhost)\n\u001B[1;32m   1160\u001B[0m \u001B[38;5;66;03m# Python 3.3 compatibility: emulate the check_hostname behavior\u001B[39;00m\n",
+      "\u001B[0;31mKeyboardInterrupt\u001B[0m: "
+     ]
     }
    ],
    "source": [
-    "agent_chain.run(input=\"What is ChatGPT?\")"
+    "agent_executor.invoke({\"input\": \"What is ChatGPT?\"})"
    ]
   },
   {
@@ -179,15 +196,15 @@
      "text": [
       "\n",
       "\n",
-      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3mThought: I need to find out who developed ChatGPT\n",
+      "\u001B[1m> Entering new AgentExecutor chain...\u001B[0m\n",
+      "\u001B[32;1m\u001B[1;3mThought: I need to find out who developed ChatGPT\n",
       "Action: Search\n",
-      "Action Input: Who developed ChatGPT\u001b[0m\n",
-      "Observation: \u001b[36;1m\u001b[1;3mChatGPT is an artificial intelligence chatbot developed by OpenAI and launched in November 2022. It is built on top of OpenAI's GPT-3 family of large ... Feb 15, 2023 ... Who owns Chat GPT? Chat GPT is owned and developed by AI research and deployment company, OpenAI. The organization is headquartered in San ... Feb 8, 2023 ... ChatGPT is an AI chatbot developed by San Francisco-based startup OpenAI. OpenAI was co-founded in 2015 by Elon Musk and Sam Altman and is ... Dec 7, 2022 ... ChatGPT is an AI chatbot designed and developed by OpenAI. The bot works by generating text responses based on human-user input, like questions ... Jan 12, 2023 ... In 2019, Microsoft invested $1 billion in OpenAI, the tiny San Francisco company that designed ChatGPT. And in the years since, it has quietly ... Jan 25, 2023 ... The inside story of ChatGPT: How OpenAI founder Sam Altman built the world's hottest technology with billions from Microsoft. Dec 3, 2022 ... ChatGPT went viral on social media for its ability to do anything from code to write essays. · The company that created the AI chatbot has a ... Jan 17, 2023 ... While many Americans were nursing hangovers on New Year's Day, 22-year-old Edward Tian was working feverishly on a new app to combat misuse ... ChatGPT is a language model created by OpenAI, an artificial intelligence research laboratory consisting of a team of researchers and engineers focused on ... 1 day ago ... Everyone is talking about ChatGPT, developed by OpenAI. This is such a great tool that has helped to make AI more accessible to a wider ...\u001b[0m\n",
-      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
-      "Final Answer: ChatGPT was developed by OpenAI.\u001b[0m\n",
+      "Action Input: Who developed ChatGPT\u001B[0m\n",
+      "Observation: \u001B[36;1m\u001B[1;3mChatGPT is an artificial intelligence chatbot developed by OpenAI and launched in November 2022. It is built on top of OpenAI's GPT-3 family of large ... Feb 15, 2023 ... Who owns Chat GPT? Chat GPT is owned and developed by AI research and deployment company, OpenAI. The organization is headquartered in San ... Feb 8, 2023 ... ChatGPT is an AI chatbot developed by San Francisco-based startup OpenAI. OpenAI was co-founded in 2015 by Elon Musk and Sam Altman and is ... Dec 7, 2022 ... ChatGPT is an AI chatbot designed and developed by OpenAI. The bot works by generating text responses based on human-user input, like questions ... Jan 12, 2023 ... In 2019, Microsoft invested $1 billion in OpenAI, the tiny San Francisco company that designed ChatGPT. And in the years since, it has quietly ... Jan 25, 2023 ... The inside story of ChatGPT: How OpenAI founder Sam Altman built the world's hottest technology with billions from Microsoft. Dec 3, 2022 ... ChatGPT went viral on social media for its ability to do anything from code to write essays. · The company that created the AI chatbot has a ... Jan 17, 2023 ... While many Americans were nursing hangovers on New Year's Day, 22-year-old Edward Tian was working feverishly on a new app to combat misuse ... ChatGPT is a language model created by OpenAI, an artificial intelligence research laboratory consisting of a team of researchers and engineers focused on ... 1 day ago ... Everyone is talking about ChatGPT, developed by OpenAI. This is such a great tool that has helped to make AI more accessible to a wider ...\u001B[0m\n",
+      "Thought:\u001B[32;1m\u001B[1;3m I now know the final answer\n",
+      "Final Answer: ChatGPT was developed by OpenAI.\u001B[0m\n",
       "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
+      "\u001B[1m> Finished chain.\u001B[0m\n"
      ]
     },
     {
@@ -202,7 +219,7 @@
     }
    ],
    "source": [
-    "agent_chain.run(input=\"Who developed it?\")"
+    "agent_executor.invoke({\"input\": \"Who developed it?\"})"
    ]
   },
   {
@@ -217,14 +234,14 @@
      "text": [
       "\n",
       "\n",
-      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3mThought: I need to simplify the conversation for a 5 year old.\n",
+      "\u001B[1m> Entering new AgentExecutor chain...\u001B[0m\n",
+      "\u001B[32;1m\u001B[1;3mThought: I need to simplify the conversation for a 5 year old.\n",
       "Action: Summary\n",
-      "Action Input: My daughter 5 years old\u001b[0m\n",
+      "Action Input: My daughter 5 years old\u001B[0m\n",
       "\n",
-      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
+      "\u001B[1m> Entering new LLMChain chain...\u001B[0m\n",
       "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mThis is a conversation between a human and a bot:\n",
+      "\u001B[32;1m\u001B[1;3mThis is a conversation between a human and a bot:\n",
       "\n",
       "Human: What is ChatGPT?\n",
       "AI: ChatGPT is an artificial intelligence chatbot developed by OpenAI and launched in November 2022. It is built on top of OpenAI's GPT-3 family of large language models and is optimized for dialogue by using Reinforcement Learning with Human-in-the-Loop. It is also capable of sending and receiving images during chatting.\n",
@@ -232,16 +249,16 @@
       "AI: ChatGPT was developed by OpenAI.\n",
       "\n",
       "Write a summary of the conversation for My daughter 5 years old:\n",
-      "\u001b[0m\n",
+      "\u001B[0m\n",
       "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "\u001B[1m> Finished chain.\u001B[0m\n",
       "\n",
-      "Observation: \u001b[33;1m\u001b[1;3m\n",
-      "The conversation was about ChatGPT, an artificial intelligence chatbot. It was created by OpenAI and can send and receive images while chatting.\u001b[0m\n",
-      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer.\n",
-      "Final Answer: ChatGPT is an artificial intelligence chatbot created by OpenAI that can send and receive images while chatting.\u001b[0m\n",
+      "Observation: \u001B[33;1m\u001B[1;3m\n",
+      "The conversation was about ChatGPT, an artificial intelligence chatbot. It was created by OpenAI and can send and receive images while chatting.\u001B[0m\n",
+      "Thought:\u001B[32;1m\u001B[1;3m I now know the final answer.\n",
+      "Final Answer: ChatGPT is an artificial intelligence chatbot created by OpenAI that can send and receive images while chatting.\u001B[0m\n",
       "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
+      "\u001B[1m> Finished chain.\u001B[0m\n"
      ]
     },
     {
@@ -256,8 +273,8 @@
     }
    ],
    "source": [
-    "agent_chain.run(\n",
-    "    input=\"Thanks. Summarize the conversation, for my daughter 5 years old.\"\n",
+    "agent_executor.invoke(\n",
+    "    {\"input\": \"Thanks. Summarize the conversation, for my daughter 5 years old.\"}\n",
     ")"
    ]
   },
@@ -289,9 +306,17 @@
     }
    ],
    "source": [
-    "print(agent_chain.memory.buffer)"
+    "print(agent_executor.memory.buffer)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "84ca95c30e262e00",
+   "metadata": {
+    "collapsed": false
+   },
+   "source": []
+  },
   {
    "cell_type": "markdown",
    "id": "cc3d0aa4",
@@ -340,25 +365,9 @@
     "    ),\n",
     "]\n",
     "\n",
-    "prefix = \"\"\"Have a conversation with a human, answering the following questions as best you can. You have access to the following tools:\"\"\"\n",
-    "suffix = \"\"\"Begin!\"\n",
-    "\n",
-    "{chat_history}\n",
-    "Question: {input}\n",
-    "{agent_scratchpad}\"\"\"\n",
-    "\n",
-    "prompt = ZeroShotAgent.create_prompt(\n",
-    "    tools,\n",
-    "    prefix=prefix,\n",
-    "    suffix=suffix,\n",
-    "    input_variables=[\"input\", \"chat_history\", \"agent_scratchpad\"],\n",
-    ")\n",
-    "\n",
-    "llm_chain = LLMChain(llm=OpenAI(temperature=0), prompt=prompt)\n",
-    "agent = ZeroShotAgent(llm_chain=llm_chain, tools=tools, verbose=True)\n",
-    "agent_chain = AgentExecutor.from_agent_and_tools(\n",
-    "    agent=agent, tools=tools, verbose=True, memory=memory\n",
-    ")"
+    "prompt = hub.pull(\"hwchase17/react\")\n",
+    "agent = create_react_agent(model, tools, prompt)\n",
+    "agent_executor = AgentExecutor(agent=agent, tools=tools, memory=memory)"
    ]
   },
   {
@@ -373,15 +382,15 @@
      "text": [
       "\n",
       "\n",
-      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3mThought: I should research ChatGPT to answer this question.\n",
+      "\u001B[1m> Entering new AgentExecutor chain...\u001B[0m\n",
+      "\u001B[32;1m\u001B[1;3mThought: I should research ChatGPT to answer this question.\n",
       "Action: Search\n",
-      "Action Input: \"ChatGPT\"\u001b[0m\n",
-      "Observation: \u001b[36;1m\u001b[1;3mNov 30, 2022 ... We've trained a model called ChatGPT which interacts in a conversational way. The dialogue format makes it possible for ChatGPT to answer ... ChatGPT is an artificial intelligence chatbot developed by OpenAI and launched in November 2022. It is built on top of OpenAI's GPT-3 family of large ... ChatGPT. We've trained a model called ChatGPT which interacts in a conversational way. The dialogue format makes it possible for ChatGPT to answer ... Feb 2, 2023 ... ChatGPT, the popular chatbot from OpenAI, is estimated to have reached 100 million monthly active users in January, just two months after ... 2 days ago ... ChatGPT recently launched a new version of its own plagiarism detection tool, with hopes that it will squelch some of the criticism around how ... An API for accessing new AI models developed by OpenAI. Feb 19, 2023 ... ChatGPT is an AI chatbot system that OpenAI released in November to show off and test what a very large, powerful AI system can accomplish. You ... ChatGPT is fine-tuned from GPT-3.5, a language model trained to produce text. ChatGPT was optimized for dialogue by using Reinforcement Learning with Human ... 3 days ago ... Visual ChatGPT connects ChatGPT and a series of Visual Foundation Models to enable sending and receiving images during chatting. Dec 1, 2022 ... ChatGPT is a natural language processing tool driven by AI technology that allows you to have human-like conversations and much more with a ...\u001b[0m\n",
-      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer.\n",
-      "Final Answer: ChatGPT is an artificial intelligence chatbot developed by OpenAI and launched in November 2022. It is built on top of OpenAI's GPT-3 family of large language models and is optimized for dialogue by using Reinforcement Learning with Human-in-the-Loop. It is also capable of sending and receiving images during chatting.\u001b[0m\n",
+      "Action Input: \"ChatGPT\"\u001B[0m\n",
+      "Observation: \u001B[36;1m\u001B[1;3mNov 30, 2022 ... We've trained a model called ChatGPT which interacts in a conversational way. The dialogue format makes it possible for ChatGPT to answer ... ChatGPT is an artificial intelligence chatbot developed by OpenAI and launched in November 2022. It is built on top of OpenAI's GPT-3 family of large ... ChatGPT. We've trained a model called ChatGPT which interacts in a conversational way. The dialogue format makes it possible for ChatGPT to answer ... Feb 2, 2023 ... ChatGPT, the popular chatbot from OpenAI, is estimated to have reached 100 million monthly active users in January, just two months after ... 2 days ago ... ChatGPT recently launched a new version of its own plagiarism detection tool, with hopes that it will squelch some of the criticism around how ... An API for accessing new AI models developed by OpenAI. Feb 19, 2023 ... ChatGPT is an AI chatbot system that OpenAI released in November to show off and test what a very large, powerful AI system can accomplish. You ... ChatGPT is fine-tuned from GPT-3.5, a language model trained to produce text. ChatGPT was optimized for dialogue by using Reinforcement Learning with Human ... 3 days ago ... Visual ChatGPT connects ChatGPT and a series of Visual Foundation Models to enable sending and receiving images during chatting. Dec 1, 2022 ... ChatGPT is a natural language processing tool driven by AI technology that allows you to have human-like conversations and much more with a ...\u001B[0m\n",
+      "Thought:\u001B[32;1m\u001B[1;3m I now know the final answer.\n",
+      "Final Answer: ChatGPT is an artificial intelligence chatbot developed by OpenAI and launched in November 2022. It is built on top of OpenAI's GPT-3 family of large language models and is optimized for dialogue by using Reinforcement Learning with Human-in-the-Loop. It is also capable of sending and receiving images during chatting.\u001B[0m\n",
       "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
+      "\u001B[1m> Finished chain.\u001B[0m\n"
      ]
     },
     {
@@ -396,7 +405,7 @@
     }
    ],
    "source": [
-    "agent_chain.run(input=\"What is ChatGPT?\")"
+    "agent_executor.invoke({\"input\": \"What is ChatGPT?\"})"
    ]
   },
   {
@@ -411,15 +420,15 @@
      "text": [
       "\n",
       "\n",
-      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3mThought: I need to find out who developed ChatGPT\n",
+      "\u001B[1m> Entering new AgentExecutor chain...\u001B[0m\n",
+      "\u001B[32;1m\u001B[1;3mThought: I need to find out who developed ChatGPT\n",
       "Action: Search\n",
-      "Action Input: Who developed ChatGPT\u001b[0m\n",
-      "Observation: \u001b[36;1m\u001b[1;3mChatGPT is an artificial intelligence chatbot developed by OpenAI and launched in November 2022. It is built on top of OpenAI's GPT-3 family of large ... Feb 15, 2023 ... Who owns Chat GPT? Chat GPT is owned and developed by AI research and deployment company, OpenAI. The organization is headquartered in San ... Feb 8, 2023 ... ChatGPT is an AI chatbot developed by San Francisco-based startup OpenAI. OpenAI was co-founded in 2015 by Elon Musk and Sam Altman and is ... Dec 7, 2022 ... ChatGPT is an AI chatbot designed and developed by OpenAI. The bot works by generating text responses based on human-user input, like questions ... Jan 12, 2023 ... In 2019, Microsoft invested $1 billion in OpenAI, the tiny San Francisco company that designed ChatGPT. And in the years since, it has quietly ... Jan 25, 2023 ... The inside story of ChatGPT: How OpenAI founder Sam Altman built the world's hottest technology with billions from Microsoft. Dec 3, 2022 ... ChatGPT went viral on social media for its ability to do anything from code to write essays. · The company that created the AI chatbot has a ... Jan 17, 2023 ... While many Americans were nursing hangovers on New Year's Day, 22-year-old Edward Tian was working feverishly on a new app to combat misuse ... ChatGPT is a language model created by OpenAI, an artificial intelligence research laboratory consisting of a team of researchers and engineers focused on ... 1 day ago ... Everyone is talking about ChatGPT, developed by OpenAI. This is such a great tool that has helped to make AI more accessible to a wider ...\u001b[0m\n",
-      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer\n",
-      "Final Answer: ChatGPT was developed by OpenAI.\u001b[0m\n",
+      "Action Input: Who developed ChatGPT\u001B[0m\n",
+      "Observation: \u001B[36;1m\u001B[1;3mChatGPT is an artificial intelligence chatbot developed by OpenAI and launched in November 2022. It is built on top of OpenAI's GPT-3 family of large ... Feb 15, 2023 ... Who owns Chat GPT? Chat GPT is owned and developed by AI research and deployment company, OpenAI. The organization is headquartered in San ... Feb 8, 2023 ... ChatGPT is an AI chatbot developed by San Francisco-based startup OpenAI. OpenAI was co-founded in 2015 by Elon Musk and Sam Altman and is ... Dec 7, 2022 ... ChatGPT is an AI chatbot designed and developed by OpenAI. The bot works by generating text responses based on human-user input, like questions ... Jan 12, 2023 ... In 2019, Microsoft invested $1 billion in OpenAI, the tiny San Francisco company that designed ChatGPT. And in the years since, it has quietly ... Jan 25, 2023 ... The inside story of ChatGPT: How OpenAI founder Sam Altman built the world's hottest technology with billions from Microsoft. Dec 3, 2022 ... ChatGPT went viral on social media for its ability to do anything from code to write essays. · The company that created the AI chatbot has a ... Jan 17, 2023 ... While many Americans were nursing hangovers on New Year's Day, 22-year-old Edward Tian was working feverishly on a new app to combat misuse ... ChatGPT is a language model created by OpenAI, an artificial intelligence research laboratory consisting of a team of researchers and engineers focused on ... 1 day ago ... Everyone is talking about ChatGPT, developed by OpenAI. This is such a great tool that has helped to make AI more accessible to a wider ...\u001B[0m\n",
+      "Thought:\u001B[32;1m\u001B[1;3m I now know the final answer\n",
+      "Final Answer: ChatGPT was developed by OpenAI.\u001B[0m\n",
       "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
+      "\u001B[1m> Finished chain.\u001B[0m\n"
      ]
     },
     {
@@ -434,7 +443,7 @@
     }
    ],
    "source": [
-    "agent_chain.run(input=\"Who developed it?\")"
+    "agent_executor.invoke({\"input\": \"Who developed it?\"})"
    ]
   },
   {
@@ -449,14 +458,14 @@
      "text": [
       "\n",
       "\n",
-      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3mThought: I need to simplify the conversation for a 5 year old.\n",
+      "\u001B[1m> Entering new AgentExecutor chain...\u001B[0m\n",
+      "\u001B[32;1m\u001B[1;3mThought: I need to simplify the conversation for a 5 year old.\n",
       "Action: Summary\n",
-      "Action Input: My daughter 5 years old\u001b[0m\n",
+      "Action Input: My daughter 5 years old\u001B[0m\n",
       "\n",
-      "\u001b[1m> Entering new LLMChain chain...\u001b[0m\n",
+      "\u001B[1m> Entering new LLMChain chain...\u001B[0m\n",
       "Prompt after formatting:\n",
-      "\u001b[32;1m\u001b[1;3mThis is a conversation between a human and a bot:\n",
+      "\u001B[32;1m\u001B[1;3mThis is a conversation between a human and a bot:\n",
       "\n",
       "Human: What is ChatGPT?\n",
       "AI: ChatGPT is an artificial intelligence chatbot developed by OpenAI and launched in November 2022. It is built on top of OpenAI's GPT-3 family of large language models and is optimized for dialogue by using Reinforcement Learning with Human-in-the-Loop. It is also capable of sending and receiving images during chatting.\n",
@@ -464,16 +473,16 @@
       "AI: ChatGPT was developed by OpenAI.\n",
       "\n",
       "Write a summary of the conversation for My daughter 5 years old:\n",
-      "\u001b[0m\n",
+      "\u001B[0m\n",
       "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "\u001B[1m> Finished chain.\u001B[0m\n",
       "\n",
-      "Observation: \u001b[33;1m\u001b[1;3m\n",
-      "The conversation was about ChatGPT, an artificial intelligence chatbot developed by OpenAI. It is designed to have conversations with humans and can also send and receive images.\u001b[0m\n",
-      "Thought:\u001b[32;1m\u001b[1;3m I now know the final answer.\n",
-      "Final Answer: ChatGPT is an artificial intelligence chatbot developed by OpenAI that can have conversations with humans and send and receive images.\u001b[0m\n",
+      "Observation: \u001B[33;1m\u001B[1;3m\n",
+      "The conversation was about ChatGPT, an artificial intelligence chatbot developed by OpenAI. It is designed to have conversations with humans and can also send and receive images.\u001B[0m\n",
+      "Thought:\u001B[32;1m\u001B[1;3m I now know the final answer.\n",
+      "Final Answer: ChatGPT is an artificial intelligence chatbot developed by OpenAI that can have conversations with humans and send and receive images.\u001B[0m\n",
       "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
+      "\u001B[1m> Finished chain.\u001B[0m\n"
      ]
     },
     {
@@ -488,8 +497,8 @@
     }
    ],
    "source": [
-    "agent_chain.run(\n",
-    "    input=\"Thanks. Summarize the conversation, for my daughter 5 years old.\"\n",
+    "agent_executor.invoke(\n",
+    "    {\"input\": \"Thanks. Summarize the conversation, for my daughter 5 years old.\"}\n",
     ")"
    ]
   },
@@ -524,7 +533,7 @@
     }
    ],
    "source": [
-    "print(agent_chain.memory.buffer)"
+    "print(agent_executor.memory.buffer)"
    ]
   }
  ],

cookbook/together_ai.ipynb

@@ -9,7 +9,7 @@
     " \n",
     "[Together AI](https://python.langchain.com/docs/integrations/llms/together) has a broad set of OSS LLMs via inference API.\n",
     "\n",
-    "See [here](https://api.together.xyz/playground). We use `\"mistralai/Mixtral-8x7B-Instruct-v0.1` for RAG on the Mixtral paper.\n",
+    "See [here](https://docs.together.ai/docs/inference-models). We use `\"mistralai/Mixtral-8x7B-Instruct-v0.1` for RAG on the Mixtral paper.\n",
     "\n",
     "Download the paper:\n",
     "https://arxiv.org/pdf/2401.04088.pdf"
@@ -148,7 +148,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.16"
+   "version": "3.9.6"
   }
  },
  "nbformat": 4,

cookbook/tool_call_messages.ipynb

@@ -0,0 +1,199 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "c48812ed-35bd-4fbe-9a2c-6c7335e5645e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_anthropic import ChatAnthropic\n",
+    "from langchain_core.runnables import ConfigurableField\n",
+    "from langchain_core.tools import tool\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "\n",
+    "\n",
+    "@tool\n",
+    "def multiply(x: float, y: float) -> float:\n",
+    "    \"\"\"Multiply 'x' times 'y'.\"\"\"\n",
+    "    return x * y\n",
+    "\n",
+    "\n",
+    "@tool\n",
+    "def exponentiate(x: float, y: float) -> float:\n",
+    "    \"\"\"Raise 'x' to the 'y'.\"\"\"\n",
+    "    return x**y\n",
+    "\n",
+    "\n",
+    "@tool\n",
+    "def add(x: float, y: float) -> float:\n",
+    "    \"\"\"Add 'x' and 'y'.\"\"\"\n",
+    "    return x + y\n",
+    "\n",
+    "\n",
+    "tools = [multiply, exponentiate, add]\n",
+    "\n",
+    "gpt35 = ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0).bind_tools(tools)\n",
+    "claude3 = ChatAnthropic(model=\"claude-3-sonnet-20240229\").bind_tools(tools)\n",
+    "llm_with_tools = gpt35.configurable_alternatives(\n",
+    "    ConfigurableField(id=\"llm\"), default_key=\"gpt35\", claude3=claude3\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9c186263-1b98-4cb2-b6d1-71f65eb0d811",
+   "metadata": {},
+   "source": [
+    "# LangGraph"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "28fc2c60-7dbc-428a-8983-1a6a15ea30d2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import operator\n",
+    "from typing import Annotated, Sequence, TypedDict\n",
+    "\n",
+    "from langchain_core.messages import AIMessage, BaseMessage, HumanMessage, ToolMessage\n",
+    "from langchain_core.runnables import RunnableLambda\n",
+    "from langgraph.graph import END, StateGraph\n",
+    "\n",
+    "\n",
+    "class AgentState(TypedDict):\n",
+    "    messages: Annotated[Sequence[BaseMessage], operator.add]\n",
+    "\n",
+    "\n",
+    "def should_continue(state):\n",
+    "    return \"continue\" if state[\"messages\"][-1].tool_calls else \"end\"\n",
+    "\n",
+    "\n",
+    "def call_model(state, config):\n",
+    "    return {\"messages\": [llm_with_tools.invoke(state[\"messages\"], config=config)]}\n",
+    "\n",
+    "\n",
+    "def _invoke_tool(tool_call):\n",
+    "    tool = {tool.name: tool for tool in tools}[tool_call[\"name\"]]\n",
+    "    return ToolMessage(tool.invoke(tool_call[\"args\"]), tool_call_id=tool_call[\"id\"])\n",
+    "\n",
+    "\n",
+    "tool_executor = RunnableLambda(_invoke_tool)\n",
+    "\n",
+    "\n",
+    "def call_tools(state):\n",
+    "    last_message = state[\"messages\"][-1]\n",
+    "    return {\"messages\": tool_executor.batch(last_message.tool_calls)}\n",
+    "\n",
+    "\n",
+    "workflow = StateGraph(AgentState)\n",
+    "workflow.add_node(\"agent\", call_model)\n",
+    "workflow.add_node(\"action\", call_tools)\n",
+    "workflow.set_entry_point(\"agent\")\n",
+    "workflow.add_conditional_edges(\n",
+    "    \"agent\",\n",
+    "    should_continue,\n",
+    "    {\n",
+    "        \"continue\": \"action\",\n",
+    "        \"end\": END,\n",
+    "    },\n",
+    ")\n",
+    "workflow.add_edge(\"action\", \"agent\")\n",
+    "graph = workflow.compile()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "3710e724-2595-4625-ba3a-effb81e66e4a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'messages': [HumanMessage(content=\"what's 3 plus 5 raised to the 2.743. also what's 17.24 - 918.1241\"),\n",
+       "  AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_6yMU2WsS4Bqgi1WxFHxtfJRc', 'function': {'arguments': '{\"x\": 8, \"y\": 2.743}', 'name': 'exponentiate'}, 'type': 'function'}, {'id': 'call_GAL3dQiKFF9XEV0RrRLPTvVp', 'function': {'arguments': '{\"x\": 17.24, \"y\": -918.1241}', 'name': 'add'}, 'type': 'function'}]}, response_metadata={'token_usage': {'completion_tokens': 58, 'prompt_tokens': 168, 'total_tokens': 226}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-528302fc-7acf-4c11-82c4-119ccf40c573-0', tool_calls=[{'name': 'exponentiate', 'args': {'x': 8, 'y': 2.743}, 'id': 'call_6yMU2WsS4Bqgi1WxFHxtfJRc'}, {'name': 'add', 'args': {'x': 17.24, 'y': -918.1241}, 'id': 'call_GAL3dQiKFF9XEV0RrRLPTvVp'}]),\n",
+       "  ToolMessage(content='300.03770462067547', tool_call_id='call_6yMU2WsS4Bqgi1WxFHxtfJRc'),\n",
+       "  ToolMessage(content='-900.8841', tool_call_id='call_GAL3dQiKFF9XEV0RrRLPTvVp'),\n",
+       "  AIMessage(content='The result of \\\\(3 + 5^{2.743}\\\\) is approximately 300.04, and the result of \\\\(17.24 - 918.1241\\\\) is approximately -900.88.', response_metadata={'token_usage': {'completion_tokens': 44, 'prompt_tokens': 251, 'total_tokens': 295}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'stop', 'logprobs': None}, id='run-d1161669-ed09-4b18-94bd-6d8530df5aa8-0')]}"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "graph.invoke(\n",
+    "    {\n",
+    "        \"messages\": [\n",
+    "            HumanMessage(\n",
+    "                \"what's 3 plus 5 raised to the 2.743. also what's 17.24 - 918.1241\"\n",
+    "            )\n",
+    "        ]\n",
+    "    }\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "073c074e-d722-42e0-85ec-c62c079207e4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'messages': [HumanMessage(content=\"what's 3 plus 5 raised to the 2.743. also what's 17.24 - 918.1241\"),\n",
+       "  AIMessage(content=[{'text': \"Okay, let's break this down into two parts:\", 'type': 'text'}, {'id': 'toolu_01DEhqcXkXTtzJAiZ7uMBeDC', 'input': {'x': 3, 'y': 5}, 'name': 'add', 'type': 'tool_use'}], response_metadata={'id': 'msg_01AkLGH8sxMHaH15yewmjwkF', 'model': 'claude-3-sonnet-20240229', 'stop_reason': 'tool_use', 'stop_sequence': None, 'usage': {'input_tokens': 450, 'output_tokens': 81}}, id='run-f35bfae8-8ded-4f8a-831b-0940d6ad16b6-0', tool_calls=[{'name': 'add', 'args': {'x': 3, 'y': 5}, 'id': 'toolu_01DEhqcXkXTtzJAiZ7uMBeDC'}]),\n",
+       "  ToolMessage(content='8.0', tool_call_id='toolu_01DEhqcXkXTtzJAiZ7uMBeDC'),\n",
+       "  AIMessage(content=[{'id': 'toolu_013DyMLrvnrto33peAKMGMr1', 'input': {'x': 8.0, 'y': 2.743}, 'name': 'exponentiate', 'type': 'tool_use'}], response_metadata={'id': 'msg_015Fmp8aztwYcce2JDAFfce3', 'model': 'claude-3-sonnet-20240229', 'stop_reason': 'tool_use', 'stop_sequence': None, 'usage': {'input_tokens': 545, 'output_tokens': 75}}, id='run-48aaeeeb-a1e5-48fd-a57a-6c3da2907b47-0', tool_calls=[{'name': 'exponentiate', 'args': {'x': 8.0, 'y': 2.743}, 'id': 'toolu_013DyMLrvnrto33peAKMGMr1'}]),\n",
+       "  ToolMessage(content='300.03770462067547', tool_call_id='toolu_013DyMLrvnrto33peAKMGMr1'),\n",
+       "  AIMessage(content=[{'text': 'So 3 plus 5 raised to the 2.743 power is 300.04.\\n\\nFor the second part:', 'type': 'text'}, {'id': 'toolu_01UTmMrGTmLpPrPCF1rShN46', 'input': {'x': 17.24, 'y': -918.1241}, 'name': 'add', 'type': 'tool_use'}], response_metadata={'id': 'msg_015TkhfRBENPib2RWAxkieH6', 'model': 'claude-3-sonnet-20240229', 'stop_reason': 'tool_use', 'stop_sequence': None, 'usage': {'input_tokens': 638, 'output_tokens': 105}}, id='run-45fb62e3-d102-4159-881d-241c5dbadeed-0', tool_calls=[{'name': 'add', 'args': {'x': 17.24, 'y': -918.1241}, 'id': 'toolu_01UTmMrGTmLpPrPCF1rShN46'}]),\n",
+       "  ToolMessage(content='-900.8841', tool_call_id='toolu_01UTmMrGTmLpPrPCF1rShN46'),\n",
+       "  AIMessage(content='Therefore, 17.24 - 918.1241 = -900.8841', response_metadata={'id': 'msg_01LgKnRuUcSyADCpxv9tPoYD', 'model': 'claude-3-sonnet-20240229', 'stop_reason': 'end_turn', 'stop_sequence': None, 'usage': {'input_tokens': 759, 'output_tokens': 24}}, id='run-1008254e-ccd1-497c-8312-9550dd77bd08-0')]}"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "graph.invoke(\n",
+    "    {\n",
+    "        \"messages\": [\n",
+    "            HumanMessage(\n",
+    "                \"what's 3 plus 5 raised to the 2.743. also what's 17.24 - 918.1241\"\n",
+    "            )\n",
+    "        ]\n",
+    "    },\n",
+    "    config={\"configurable\": {\"llm\": \"claude3\"}},\n",
+    ")"
+   ]
+  }
+ ],
+ "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
+}

cookbook/twitter-the-algorithm-analysis-deeplake.ipynb

@@ -3811,7 +3811,7 @@
     "from langchain.chains import ConversationalRetrievalChain\n",
     "from langchain_openai import ChatOpenAI\n",
     "\n",
-    "model = ChatOpenAI(model_name=\"gpt-3.5-turbo-0613\")  # switch to 'gpt-4'\n",
+    "model = ChatOpenAI(model=\"gpt-3.5-turbo-0613\")  # switch to 'gpt-4'\n",
     "qa = ConversationalRetrievalChain.from_llm(model, retriever=retriever)"
    ]
   },

cookbook/two_agent_debate_tools.ipynb

@@ -424,7 +424,7 @@
     "    DialogueAgentWithTools(\n",
     "        name=name,\n",
     "        system_message=SystemMessage(content=system_message),\n",
-    "        model=ChatOpenAI(model_name=\"gpt-4\", temperature=0.2),\n",
+    "        model=ChatOpenAI(model=\"gpt-4\", temperature=0.2),\n",
     "        tool_names=tools,\n",
     "        top_k_results=2,\n",
     "    )\n",

cookbook/video_captioning/video_captioning.ipynb

@@ -0,0 +1,174 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Video Captioning\n",
+    "This notebook shows how to use VideoCaptioningChain, which is implemented using Langchain's ImageCaptionLoader and AssemblyAI to produce .srt files.\n",
+    "\n",
+    "This system autogenerates both subtitles and closed captions from a video URL."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Installing Dependencies"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# !pip install ffmpeg-python\n",
+    "# !pip install assemblyai\n",
+    "# !pip install opencv-python\n",
+    "# !pip install torch\n",
+    "# !pip install pillow\n",
+    "# !pip install transformers\n",
+    "# !pip install langchain"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-11-30T03:39:14.078232Z",
+     "start_time": "2023-11-30T03:39:12.534410Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import getpass\n",
+    "\n",
+    "from langchain.chains.video_captioning import VideoCaptioningChain\n",
+    "from langchain.chat_models.openai import ChatOpenAI"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setting up API Keys"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-11-30T03:39:17.423806Z",
+     "start_time": "2023-11-30T03:39:17.417945Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "OPENAI_API_KEY = getpass.getpass(\"OpenAI API Key:\")\n",
+    "\n",
+    "ASSEMBLYAI_API_KEY = getpass.getpass(\"AssemblyAI API Key:\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Required parameters:**\n",
+    "\n",
+    "* llm: The language model this chain will use to get suggestions on how to refine the closed-captions\n",
+    "* assemblyai_key: The API key for AssemblyAI, used to generate the subtitles\n",
+    "\n",
+    "**Optional Parameters:**\n",
+    "\n",
+    "* verbose (Default: True): Sets verbose mode for downstream chain calls\n",
+    "* use_logging (Default: True): Log the chain's processes in run manager\n",
+    "* frame_skip (Default: None): Choose how many video frames to skip during processing. Increasing it results in faster execution, but less accurate results. If None, frame skip is calculated manually based on the framerate Set this to 0 to sample all frames\n",
+    "* image_delta_threshold (Default: 3000000): Set the sensitivity for what the image processor considers a change in scenery in the video, used to delimit closed captions. Higher = less sensitive\n",
+    "* closed_caption_char_limit (Default: 20): Sets the character limit on closed captions\n",
+    "* closed_caption_similarity_threshold (Default: 80): Sets the percentage value to how similar two closed caption models should be in order to be clustered into one longer closed caption\n",
+    "* use_unclustered_video_models (Default: False): If true, closed captions that could not be clustered will be included. May result in spontaneous behaviour from closed captions such as very short lasting captions or fast-changing captions. Enabling this is experimental and not recommended"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Example run"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# https://ia804703.us.archive.org/27/items/uh-oh-here-we-go-again/Uh-Oh%2C%20Here%20we%20go%20again.mp4\n",
+    "# https://ia601200.us.archive.org/9/items/f58703d4-61e6-4f8f-8c08-b42c7e16f7cb/f58703d4-61e6-4f8f-8c08-b42c7e16f7cb.mp4\n",
+    "\n",
+    "chain = VideoCaptioningChain(\n",
+    "    llm=ChatOpenAI(model=\"gpt-4\", max_tokens=4000, openai_api_key=OPENAI_API_KEY),\n",
+    "    assemblyai_key=ASSEMBLYAI_API_KEY,\n",
+    ")\n",
+    "\n",
+    "srt_content = chain.run(\n",
+    "    video_file_path=\"https://ia601200.us.archive.org/9/items/f58703d4-61e6-4f8f-8c08-b42c7e16f7cb/f58703d4-61e6-4f8f-8c08-b42c7e16f7cb.mp4\"\n",
+    ")\n",
+    "\n",
+    "print(srt_content)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Writing output to .srt file"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"output.srt\", \"w\") as file:\n",
+    "    file.write(srt_content)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "myenv",
+   "language": "python",
+   "name": "myenv"
+  },
+  "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.11.6"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "b0fa6594d8f4cbf19f97940f81e996739fb7646882a419484c72d19e05852a7e"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

cookbook/wikibase_agent.ipynb

@@ -601,7 +601,7 @@
    "source": [
     "from langchain_openai import ChatOpenAI\n",
     "\n",
-    "llm = ChatOpenAI(model_name=\"gpt-4\", temperature=0)"
+    "llm = ChatOpenAI(model=\"gpt-4\", temperature=0)"
    ]
   },
   {

docker/docker-compose.yml

@@ -4,14 +4,14 @@
 # ATTENTION: When adding a service below use a non-standard port
 # increment by one from the preceding port.
 # For credentials always use `langchain` and `langchain` for the
-# username and password. 
+# username and password.
 version: "3"
 name: langchain-tests
 
 services:
   redis:
     image: redis/redis-stack-server:latest
-    # We use non standard ports since 
+    # We use non standard ports since
     # these instances are used for testing
     # and users may already have existing
     # redis instances set up locally
@@ -73,6 +73,11 @@ services:
       retries: 60
     volumes:
       - postgres_data_pgvector:/var/lib/postgresql/data
+  vdms:
+    image: intellabs/vdms:latest
+    container_name: vdms_container
+    ports:
+      - "6025:55555"
 
 volumes:
   postgres_data:

docs/docs/additional_resources/dependents.mdx

@@ -241,7 +241,6 @@ Dependents stats for `langchain-ai/langchain`
 |[alejandro-ao/langchain-ask-pdf](https://github.com/alejandro-ao/langchain-ask-pdf) | 514 |
 |[sajjadium/ctf-archives](https://github.com/sajjadium/ctf-archives) | 507 |
 |[continuum-llms/chatgpt-memory](https://github.com/continuum-llms/chatgpt-memory) | 502 |
-|[llmOS/opencopilot](https://github.com/llmOS/opencopilot) | 495 |
 |[steamship-core/steamship-langchain](https://github.com/steamship-core/steamship-langchain) | 494 |
 |[mpaepper/content-chatbot](https://github.com/mpaepper/content-chatbot) | 493 |
 |[langchain-ai/langchain-aiplugin](https://github.com/langchain-ai/langchain-aiplugin) | 492 |
@@ -455,7 +454,6 @@ Dependents stats for `langchain-ai/langchain`
 |[Teahouse-Studios/akari-bot](https://github.com/Teahouse-Studios/akari-bot) | 149 |
 |[realminchoi/babyagi-ui](https://github.com/realminchoi/babyagi-ui) | 148 |
 |[ssheng/BentoChain](https://github.com/ssheng/BentoChain) | 148 |
-|[lmstudio-ai/examples](https://github.com/lmstudio-ai/examples) | 147 |
 |[solana-labs/chatgpt-plugin](https://github.com/solana-labs/chatgpt-plugin) | 147 |
 |[aurelio-labs/arxiv-bot](https://github.com/aurelio-labs/arxiv-bot) | 147 |
 |[Jaseci-Labs/jaseci](https://github.com/Jaseci-Labs/jaseci) | 146 |

docs/docs/additional_resources/tutorials.mdx

@@ -21,10 +21,10 @@
 
 ### Featured courses on Deeplearning.AI
 
-- [LangChain for LLM Application Development](https://learn.deeplearning.ai/langchain)
-- [LangChain Chat with Your Data](https://learn.deeplearning.ai/langchain-chat-with-your-data)
-- [Functions, Tools and Agents with LangChain](https://learn.deeplearning.ai/functions-tools-agents-langchain)
-- [Build LLM Apps with LangChain.js](https://learn.deeplearning.ai/courses/build-llm-apps-with-langchain-js)
+- [LangChain for LLM Application Development](https://www.deeplearning.ai/short-courses/langchain-for-llm-application-development/)
+- [LangChain Chat with Your Data](https://www.deeplearning.ai/short-courses/langchain-chat-with-your-data/)
+- [Functions, Tools and Agents with LangChain](https://www.deeplearning.ai/short-courses/functions-tools-agents-langchain/)
+- [Build LLM Apps with LangChain.js](https://www.deeplearning.ai/short-courses/build-llm-apps-with-langchain-js/)
 
 ### Online courses
 

docs/docs/additional_resources/youtube.mdx

@@ -7,7 +7,7 @@
 ### Introduction to LangChain with Harrison Chase, creator of LangChain
 - [Building the Future with LLMs, `LangChain`, & `Pinecone`](https://youtu.be/nMniwlGyX-c) by [Pinecone](https://www.youtube.com/@pinecone-io)
 - [LangChain and Weaviate with Harrison Chase and Bob van Luijt - Weaviate Podcast #36](https://youtu.be/lhby7Ql7hbk) by [Weaviate • Vector Database](https://www.youtube.com/@Weaviate)
-- [LangChain Demo + Q&A with Harrison Chase](https://youtu.be/zaYTXQFR0_s?t=788) by [Full Stack Deep Learning](https://www.youtube.com/@FullStackDeepLearning)
+- [LangChain Demo + Q&A with Harrison Chase](https://youtu.be/zaYTXQFR0_s?t=788) by [Full Stack Deep Learning](https://www.youtube.com/@The_Full_Stack)
 - [LangChain Agents: Build Personal Assistants For Your Data (Q&A with Harrison Chase and Mayo Oshin)](https://youtu.be/gVkF8cwfBLI) by [Chat with data](https://www.youtube.com/@chatwithdata)
 
 ## Videos (sorted by views)
@@ -15,8 +15,8 @@
 - [Using `ChatGPT` with YOUR OWN Data. This is magical. (LangChain OpenAI API)](https://youtu.be/9AXP7tCI9PI) by [TechLead](https://www.youtube.com/@TechLead)
 - [First look - `ChatGPT` + `WolframAlpha` (`GPT-3.5` and Wolfram|Alpha via LangChain by James Weaver)](https://youtu.be/wYGbY811oMo) by [Dr Alan D. Thompson](https://www.youtube.com/@DrAlanDThompson) 
 - [LangChain explained - The hottest new Python framework](https://youtu.be/RoR4XJw8wIc) by [AssemblyAI](https://www.youtube.com/@AssemblyAI)
-- [Chatbot with INFINITE MEMORY using `OpenAI` & `Pinecone` - `GPT-3`, `Embeddings`, `ADA`, `Vector DB`, `Semantic`](https://youtu.be/2xNzB7xq8nk) by [David Shapiro ~ AI](https://www.youtube.com/@DavidShapiroAutomator)
-- [LangChain for LLMs is... basically just an Ansible playbook](https://youtu.be/X51N9C-OhlE) by [David Shapiro ~ AI](https://www.youtube.com/@DavidShapiroAutomator)
+- [Chatbot with INFINITE MEMORY using `OpenAI` & `Pinecone` - `GPT-3`, `Embeddings`, `ADA`, `Vector DB`, `Semantic`](https://youtu.be/2xNzB7xq8nk) by [David Shapiro ~ AI](https://www.youtube.com/@DaveShap)
+- [LangChain for LLMs is... basically just an Ansible playbook](https://youtu.be/X51N9C-OhlE) by [David Shapiro ~ AI](https://www.youtube.com/@DaveShap)
 - [Build your own LLM Apps with LangChain & `GPT-Index`](https://youtu.be/-75p09zFUJY) by [1littlecoder](https://www.youtube.com/@1littlecoder)
 - [`BabyAGI` - New System of Autonomous AI Agents with LangChain](https://youtu.be/lg3kJvf1kXo) by [1littlecoder](https://www.youtube.com/@1littlecoder)
 - [Run `BabyAGI` with Langchain Agents (with Python Code)](https://youtu.be/WosPGHPObx8) by [1littlecoder](https://www.youtube.com/@1littlecoder)
@@ -37,15 +37,15 @@
 - [Building AI LLM Apps with LangChain (and more?) - LIVE STREAM](https://www.youtube.com/live/M-2Cj_2fzWI?feature=share) by [Nicholas Renotte](https://www.youtube.com/@NicholasRenotte)
 - [`ChatGPT` with any `YouTube` video using langchain and `chromadb`](https://youtu.be/TQZfB2bzVwU) by [echohive](https://www.youtube.com/@echohive)
 - [How to Talk to a `PDF` using LangChain and `ChatGPT`](https://youtu.be/v2i1YDtrIwk) by [Automata Learning Lab](https://www.youtube.com/@automatalearninglab)
-- [Langchain Document Loaders Part 1: Unstructured Files](https://youtu.be/O5C0wfsen98) by [Merk](https://www.youtube.com/@merksworld) 
-- [LangChain - Prompt Templates (what all the best prompt engineers use)](https://youtu.be/1aRu8b0XNOQ) by [Nick Daigler](https://www.youtube.com/@nick_daigs)
+- [Langchain Document Loaders Part 1: Unstructured Files](https://youtu.be/O5C0wfsen98) by [Merk](https://www.youtube.com/@heymichaeldaigler) 
+- [LangChain - Prompt Templates (what all the best prompt engineers use)](https://youtu.be/1aRu8b0XNOQ) by [Nick Daigler](https://www.youtube.com/@nickdaigler)
 - [LangChain. Crear aplicaciones Python impulsadas por GPT](https://youtu.be/DkW_rDndts8) by [Jesús Conde](https://www.youtube.com/@0utKast)
 - [Easiest Way to Use GPT In Your Products | LangChain Basics Tutorial](https://youtu.be/fLy0VenZyGc) by [Rachel Woods](https://www.youtube.com/@therachelwoods)
 - [`BabyAGI` + `GPT-4` Langchain Agent with Internet Access](https://youtu.be/wx1z_hs5P6E) by [tylerwhatsgood](https://www.youtube.com/@tylerwhatsgood)
 - [Learning LLM Agents. How does it actually work? LangChain, AutoGPT & OpenAI](https://youtu.be/mb_YAABSplk) by [Arnoldas Kemeklis](https://www.youtube.com/@processusAI)
 - [Get Started with LangChain in `Node.js`](https://youtu.be/Wxx1KUWJFv4) by [Developers Digest](https://www.youtube.com/@DevelopersDigest)
 - [LangChain + `OpenAI` tutorial: Building a Q&A system w/ own text data](https://youtu.be/DYOU_Z0hAwo) by [Samuel Chan](https://www.youtube.com/@SamuelChan)
-- [Langchain + `Zapier` Agent](https://youtu.be/yribLAb-pxA) by [Merk](https://www.youtube.com/@merksworld)
+- [Langchain + `Zapier` Agent](https://youtu.be/yribLAb-pxA) by [Merk](https://www.youtube.com/@heymichaeldaigler)
 - [Connecting the Internet with `ChatGPT` (LLMs) using Langchain And Answers Your Questions](https://youtu.be/9Y0TBC63yZg) by [Kamalraj M M](https://www.youtube.com/@insightbuilder)
 - [Build More Powerful LLM Applications for Business’s with LangChain (Beginners Guide)](https://youtu.be/sp3-WLKEcBg) by[ No Code Blackbox](https://www.youtube.com/@nocodeblackbox)
 - [LangFlow LLM Agent Demo for 🦜🔗LangChain](https://youtu.be/zJxDHaWt-6o) by [Cobus Greyling](https://www.youtube.com/@CobusGreylingZA)
@@ -82,7 +82,7 @@
 - [Build a LangChain-based Semantic PDF Search App with No-Code Tools Bubble and Flowise](https://youtu.be/s33v5cIeqA4) by [Menlo Park Lab](https://www.youtube.com/@menloparklab)
 - [LangChain Memory Tutorial | Building a ChatGPT Clone in Python](https://youtu.be/Cwq91cj2Pnc) by [Alejandro AO - Software & Ai](https://www.youtube.com/@alejandro_ao)
 - [ChatGPT For Your DATA | Chat with Multiple Documents Using LangChain](https://youtu.be/TeDgIDqQmzs) by [Data Science Basics](https://www.youtube.com/@datasciencebasics)
-- [`Llama Index`: Chat with Documentation using URL Loader](https://youtu.be/XJRoDEctAwA) by [Merk](https://www.youtube.com/@merksworld)
+- [`Llama Index`: Chat with Documentation using URL Loader](https://youtu.be/XJRoDEctAwA) by [Merk](https://www.youtube.com/@heymichaeldaigler)
 - [Using OpenAI, LangChain, and `Gradio` to Build Custom GenAI Applications](https://youtu.be/1MsmqMg3yUc) by [David Hundley](https://www.youtube.com/@dkhundley)
 - [LangChain, Chroma DB, OpenAI Beginner Guide | ChatGPT with your PDF](https://youtu.be/FuqdVNB_8c0)
 - [Build AI chatbot with custom knowledge base using OpenAI API and GPT Index](https://youtu.be/vDZAZuaXf48) by [Irina Nik](https://www.youtube.com/@irina_nik)
@@ -93,7 +93,7 @@
 - [Build a Custom Chatbot with OpenAI: `GPT-Index` & LangChain | Step-by-Step Tutorial](https://youtu.be/FIDv6nc4CgU) by [Fabrikod](https://www.youtube.com/@fabrikod)
 - [`Flowise` is an open-source no-code UI visual tool to build 🦜🔗LangChain applications](https://youtu.be/CovAPtQPU0k) by [Cobus Greyling](https://www.youtube.com/@CobusGreylingZA)
 - [LangChain & GPT 4 For Data Analysis: The `Pandas` Dataframe Agent](https://youtu.be/rFQ5Kmkd4jc) by [Rabbitmetrics](https://www.youtube.com/@rabbitmetrics)
-- [`GirlfriendGPT` - AI girlfriend with LangChain](https://youtu.be/LiN3D1QZGQw) by [Toolfinder AI](https://www.youtube.com/@toolfinderai)
+- [`GirlfriendGPT` - AI girlfriend with LangChain](https://youtu.be/LiN3D1QZGQw) by [Girlfriend GPT](https://www.youtube.com/@girlfriendGPT)
 - [How to build with Langchain 10x easier | ⛓️ LangFlow & `Flowise`](https://youtu.be/Ya1oGL7ZTvU) by [AI Jason](https://www.youtube.com/@AIJasonZ)
 - [Getting Started With LangChain In 20 Minutes- Build Celebrity Search Application](https://youtu.be/_FpT1cwcSLg) by [Krish Naik](https://www.youtube.com/@krishnaik06)
 - ⛓ [Vector Embeddings Tutorial – Code Your Own AI Assistant with `GPT-4 API` + LangChain + NLP](https://youtu.be/yfHHvmaMkcA?si=5uJhxoh2tvdnOXok) by [FreeCodeCamp.org](https://www.youtube.com/@freecodecamp)
@@ -109,7 +109,7 @@
 - ⛓ [PyData Heidelberg #11 - TimeSeries Forecasting & LLM Langchain](https://www.youtube.com/live/Glbwb5Hxu18?si=PIEY8Raq_C9PCHuW) by [PyData](https://www.youtube.com/@PyDataTV)
 - ⛓ [Prompt Engineering in Web Development | Using LangChain and Templates with OpenAI](https://youtu.be/pK6WzlTOlYw?si=fkcDQsBG2h-DM8uQ) by [Akamai Developer
 ](https://www.youtube.com/@AkamaiDeveloper)
-- ⛓ [Retrieval-Augmented Generation (RAG) using LangChain and `Pinecone` - The RAG Special Episode](https://youtu.be/J_tCD_J6w3s?si=60Mnr5VD9UED9bGG) by [Generative AI and Data Science On AWS](https://www.youtube.com/@GenerativeAIDataScienceOnAWS)
+- ⛓ [Retrieval-Augmented Generation (RAG) using LangChain and `Pinecone` - The RAG Special Episode](https://youtu.be/J_tCD_J6w3s?si=60Mnr5VD9UED9bGG) by [Generative AI and Data Science On AWS](https://www.youtube.com/@GenerativeAIOnAWS)
 - ⛓ [`LLAMA2 70b-chat` Multiple Documents Chatbot with Langchain & Streamlit |All OPEN SOURCE|Replicate API](https://youtu.be/vhghB81vViM?si=dszzJnArMeac7lyc) by [DataInsightEdge](https://www.youtube.com/@DataInsightEdge01)
 - ⛓ [Chatting with 44K Fashion Products: LangChain Opportunities and Pitfalls](https://youtu.be/Zudgske0F_s?si=8HSshHoEhh0PemJA) by [Rabbitmetrics](https://www.youtube.com/@rabbitmetrics)
 - ⛓ [Structured Data Extraction from `ChatGPT` with LangChain](https://youtu.be/q1lYg8JISpQ?si=0HctzOHYZvq62sve) by [MG](https://www.youtube.com/@MG_cafe)

docs/docs/contributing/code.mdx

@@ -98,7 +98,7 @@ To run unit tests in Docker:
 make docker_tests
 ```
 
-There are also [integration tests and code-coverage](./testing) available.
+There are also [integration tests and code-coverage](/docs/contributing/testing/) available.
 
 ### Only develop langchain_core or langchain_experimental
 

docs/docs/contributing/documentation/_category_.yml

@@ -0,0 +1,2 @@
+label: 'Documentation'
+position: 3

docs/docs/contributing/documentation/style_guide.mdx

@@ -0,0 +1,138 @@
+---
+sidebar_label: "Style guide"
+---
+
+# LangChain Documentation Style Guide
+
+## Introduction
+
+As LangChain continues to grow, the surface area of documentation required to cover it continues to grow too.
+This page provides guidelines for anyone writing documentation for LangChain, as well as some of our philosophies around
+organization and structure.
+
+## Philosophy
+
+LangChain's documentation aspires to follow the [Diataxis framework](https://diataxis.fr).
+Under this framework, all documentation falls under one of four categories:
+
+- **Tutorials**: Lessons that take the reader by the hand through a series of conceptual steps to complete a project.
+  - An example of this is our [LCEL streaming guide](/docs/expression_language/streaming).
+  - Our guides on [custom components](/docs/modules/model_io/chat/custom_chat_model) is another one.
+- **How-to guides**: Guides that take the reader through the steps required to solve a real-world problem.
+  - The clearest examples of this are our [Use case](/docs/use_cases/) quickstart pages.
+- **Reference**: Technical descriptions of the machinery and how to operate it.
+  - Our [Runnable interface](/docs/expression_language/interface) page is an example of this.
+  - The [API reference pages](https://api.python.langchain.com/) are another.
+- **Explanation**: Explanations that clarify and illuminate a particular topic.
+  - The [LCEL primitives pages](/docs/expression_language/primitives/sequence) are an example of this.
+
+Each category serves a distinct purpose and requires a specific approach to writing and structuring the content.
+
+## Taxonomy
+
+Keeping the above in mind, we have sorted LangChain's docs into categories. It is helpful to think in these terms
+when contributing new documentation:
+
+### Getting started
+
+The [getting started section](/docs/get_started/introduction) includes a high-level introduction to LangChain, a quickstart that
+tours LangChain's various features, and logistical instructions around installation and project setup.
+
+It contains elements of **How-to guides** and **Explanations**.
+
+### Use cases
+
+[Use cases](/docs/use_cases/) are guides that are meant to show how to use LangChain to accomplish a specific task (RAG, information extraction, etc.).
+The quickstarts should be good entrypoints for first-time LangChain developers who prefer to learn by getting something practical prototyped,
+then taking the pieces apart retrospectively. These should mirror what LangChain is good at.
+
+The quickstart pages here should fit the **How-to guide** category, with the other pages intended to be **Explanations** of more
+in-depth concepts and strategies that accompany the main happy paths.
+
+:::note
+The below sections are listed roughly in order of increasing level of abstraction.
+:::
+
+### Expression Language
+
+[LangChain Expression Language (LCEL)](/docs/expression_language/) is the fundamental way that most LangChain components fit together, and this section is designed to teach
+developers how to use it to build with LangChain's primitives effectively.
+
+This section should contains **Tutorials** that teach how to stream and use LCEL primitives for more abstract tasks, **Explanations** of specific behaviors,
+and some **References** for how to use different methods in the Runnable interface.
+
+### Components
+
+The [components section](/docs/modules) covers concepts one level of abstraction higher than LCEL.
+Abstract base classes like `BaseChatModel` and `BaseRetriever` should be covered here, as well as core implementations of these base classes,
+such as `ChatPromptTemplate` and `RecursiveCharacterTextSplitter`. Customization guides belong here too.
+
+This section should contain mostly conceptual **Tutorials**, **References**, and **Explanations** of the components they cover.
+
+:::note
+As a general rule of thumb, everything covered in the `Expression Language` and `Components` sections (with the exception of the `Composition` section of components) should
+cover only components that exist in `langchain_core`.
+:::
+
+### Integrations
+
+The [integrations](/docs/integrations/platforms/) are specific implementations of components. These often involve third-party APIs and services.
+If this is the case, as a general rule, these are maintained by the third-party partner.
+
+This section should contain mostly **Explanations** and **References**, though the actual content here is more flexible than other sections and more at the
+discretion of the third-party provider.
+
+:::note
+Concepts covered in `Integrations` should generally exist in `langchain_community` or specific partner packages.
+:::
+
+### Guides and Ecosystem
+
+The [Guides](/docs/guides) and [Ecosystem](/docs/langsmith/) sections should contain guides that address higher-level problems than the sections above.
+This includes, but is not limited to, considerations around productionization and development workflows.
+
+These should contain mostly **How-to guides**, **Explanations**, and **Tutorials**.
+
+### API references
+
+LangChain's API references. Should act as **References** (as the name implies) with some **Explanation**-focused content as well. 
+
+## Sample developer journey
+
+We have set up our docs to assist a new developer to LangChain. Let's walk through the intended path:
+
+- The developer lands on https://python.langchain.com, and reads through the introduction and the diagram.
+- If they are just curious, they may be drawn to the [Quickstart](/docs/get_started/quickstart) to get a high-level tour of what LangChain contains.
+- If they have a specific task in mind that they want to accomplish, they will be drawn to the Use-Case section. The use-case should provide a good, concrete hook that shows the value LangChain can provide them and be a good entrypoint to the framework.
+- They can then move to learn more about the fundamentals of LangChain through the Expression Language sections.
+- Next, they can learn about LangChain's various components and integrations.
+- Finally, they can get additional knowledge through the Guides.
+
+This is only an ideal of course - sections will inevitably reference lower or higher-level concepts that are documented in other sections.
+
+## Guidelines
+
+Here are some other guidelines you should think about when writing and organizing documentation.
+
+### Linking to other sections
+
+Because sections of the docs do not exist in a vacuum, it is important to link to other sections as often as possible
+to allow a developer to learn more about an unfamiliar topic inline.
+
+This includes linking to the API references as well as conceptual sections!
+
+### Conciseness
+
+In general, take a less-is-more approach. If a section with a good explanation of a concept already exists, you should link to it rather than
+re-explain it, unless the concept you are documenting presents some new wrinkle.
+
+Be concise, including in code samples.
+
+### General style
+
+- Use active voice and present tense whenever possible.
+- Use examples and code snippets to illustrate concepts and usage.
+- Use appropriate header levels (`#`, `##`, `###`, etc.) to organize the content hierarchically.
+- Use bullet points and numbered lists to break down information into easily digestible chunks.
+- Use tables (especially for **Reference** sections) and diagrams often to present information visually.
+- Include the table of contents for longer documentation pages to help readers navigate the content, but hide it for shorter pages.

docs/docs/contributing/documentation/technical_logistics.mdx

@@ -1,7 +1,4 @@
----
-sidebar_position: 3
----
-# Contribute Documentation
+# Technical logistics
 
 LangChain documentation consists of two components:
 

docs/docs/contributing/index.mdx

@@ -12,7 +12,7 @@ As an open-source project in a rapidly developing field, we are extremely open t
 
 There are many ways to contribute to LangChain. Here are some common ways people contribute:
 
-- [**Documentation**](./documentation.mdx): Help improve our docs, including this one!
+- [**Documentation**](/docs/contributing/documentation/style_guide): Help improve our docs, including this one!
 - [**Code**](./code.mdx): Help us write code, fix bugs, or improve our infrastructure.
 - [**Integrations**](integrations.mdx): Help us integrate with your favorite vendors and tools.
 - [**Discussions**](https://github.com/langchain-ai/langchain/discussions): Help answer usage questions and discuss issues with users.

docs/docs/contributing/integrations.mdx

@@ -3,7 +3,7 @@ sidebar_position: 5
 ---
 # Contribute Integrations
 
-To begin, make sure you have all the dependencies outlined in guide on [Contributing Code](./code).
+To begin, make sure you have all the dependencies outlined in guide on [Contributing Code](/docs/contributing/code/).
 
 There are a few different places you can contribute integrations for LangChain:
 
@@ -14,19 +14,20 @@ For the most part, new integrations should be added to the Community package. Pa
 
 In the following sections, we'll walk through how to contribute to each of these packages from a fake company, `Parrot Link AI`.
 
-## Community Package
+## Community package
 
 The `langchain-community` package is in `libs/community` and contains most integrations.
 
-It is installed by users with `pip install langchain-community`, and exported members can be imported with code like 
+It can be installed with `pip install langchain-community`, and exported members can be imported with code like 
 
 ```python
-from langchain_community.chat_models import ParrotLinkLLM
-from langchain_community.llms import ChatParrotLink
+from langchain_community.chat_models import ChatParrotLink
+from langchain_community.llms import ParrotLinkLLM
 from langchain_community.vectorstores import ParrotLinkVectorStore
 ```
 
-The community package relies on manually-installed dependent packages, so you will see errors if you try to import a package that is not installed. In our fake example, if you tried to import `ParrotLinkLLM` without installing `parrot-link-sdk`, you will see an `ImportError` telling you to install it when trying to use it.
+The `community` package relies on manually-installed dependent packages, so you will see errors 
+if you try to import a package that is not installed. In our fake example, if you tried to import `ParrotLinkLLM` without installing `parrot-link-sdk`, you will see an `ImportError` telling you to install it when trying to use it.
 
 Let's say we wanted to implement a chat model for Parrot Link AI. We would create a new file in `libs/community/langchain_community/chat_models/parrot_link.py` with the following code:
 
@@ -39,7 +40,7 @@ class ChatParrotLink(BaseChatModel):
     Example:
         .. code-block:: python
 
-            from langchain_parrot_link import ChatParrotLink
+            from langchain_community.chat_models import ChatParrotLink
 
             model = ChatParrotLink()
     """
@@ -56,9 +57,16 @@ And add documentation to:
 
 - `docs/docs/integrations/chat/parrot_link.ipynb`
 
-## Partner Packages
+## Partner package in LangChain repo
 
-Partner packages are in `libs/partners/*` and are installed by users with `pip install langchain-{partner}`, and exported members can be imported with code like 
+Partner packages can be hosted in the `LangChain` monorepo or in an external repo.
+
+Partner package in the `LangChain` repo is placed in `libs/partners/{partner}` 
+and the package source code is in `libs/partners/{partner}/langchain_{partner}`.
+
+A package is 
+installed by users with `pip install langchain-{partner}`, and the package members 
+can be imported with code like:
 
 ```python
 from langchain_{partner} import X
@@ -123,13 +131,49 @@ By default, this will include stubs for a Chat Model, an LLM, and/or a Vector St
 
 ### Write Unit and Integration Tests
 
-Some basic tests are generated in the tests/ directory. You should add more tests to cover your package's functionality.
+Some basic tests are presented in the `tests/` directory. You should add more tests to cover your package's functionality.
 
-For information on running and implementing tests, see the [Testing guide](./testing).
+For information on running and implementing tests, see the [Testing guide](/docs/contributing/testing/).
 
 ### Write documentation
 
-Documentation is generated from Jupyter notebooks in the `docs/` directory. You should move the generated notebooks to the relevant `docs/docs/integrations` directory in the monorepo root.
+Documentation is generated from Jupyter notebooks in the `docs/` directory. You should place the notebooks with examples
+to the relevant `docs/docs/integrations` directory in the monorepo root.
+
+### (If Necessary) Deprecate community integration
+
+Note: this is only necessary if you're migrating an existing community integration into 
+a partner package. If the component you're integrating is net-new to LangChain (i.e. 
+not already in the `community` package), you can skip this step.
+
+Let's pretend we migrated our `ChatParrotLink` chat model from the community package to 
+the partner package. We would need to deprecate the old model in the community package.
+
+We would do that by adding a `@deprecated` decorator to the old model as follows, in
+`libs/community/langchain_community/chat_models/parrot_link.py`.
+
+Before our change, our chat model might look like this:
+
+```python
+class ChatParrotLink(BaseChatModel):
+  ...
+```
+
+After our change, it would look like this:
+
+```python
+from langchain_core._api.deprecation import deprecated
+
+@deprecated(
+    since="0.0.<next community version>", 
+    removal="0.2.0", 
+    alternative_import="langchain_parrot_link.ChatParrotLink"
+)
+class ChatParrotLink(BaseChatModel):
+  ...
+```
+
+You should do this for *each* component that you're migrating to the partner package.
 
 ### Additional steps
 
@@ -143,3 +187,12 @@ Maintainer steps (Contributors should **not** do these):
 - [ ] set up pypi and test pypi projects
 - [ ] add credential secrets to Github Actions
 - [ ] add package to conda-forge
+
+## Partner package in external repo
+
+Partner packages in external repos must be coordinated between the LangChain team and
+the partner organization to ensure that they are maintained and updated.
+
+If you're interested in creating a partner package in an external repo, please start
+with one in the LangChain repo, and then reach out to the LangChain team to discuss
+how to move it to an external repo.

docs/docs/contributing/repo_structure.mdx

@@ -41,7 +41,7 @@ There are other files in the root directory level, but their presence should be
 The `/docs` directory contains the content for the documentation that is shown
 at https://python.langchain.com/ and the associated API Reference https://api.python.langchain.com/en/latest/langchain_api_reference.html.
 
-See the [documentation](./documentation) guidelines to learn how to contribute to the documentation.
+See the [documentation](/docs/contributing/documentation/style_guide) guidelines to learn how to contribute to the documentation.
 
 ## Code
 

docs/docs/expression_language/cookbook/agent.ipynb

@@ -1,205 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "e89f490d",
-   "metadata": {},
-   "source": [
-    "# Agents\n",
-    "\n",
-    "You can pass a Runnable into an agent. Make sure you have `langchainhub` installed: `pip install langchainhub`"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "af4381de",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain import hub\n",
-    "from langchain.agents import AgentExecutor, tool\n",
-    "from langchain.agents.output_parsers import XMLAgentOutputParser\n",
-    "from langchain_community.chat_models import ChatAnthropic"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "24cc8134",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "model = ChatAnthropic(model=\"claude-2\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "67c0b0e4",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "@tool\n",
-    "def search(query: str) -> str:\n",
-    "    \"\"\"Search things about current events.\"\"\"\n",
-    "    return \"32 degrees\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "7203b101",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "tool_list = [search]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "b68e756d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Get the prompt to use - you can modify this!\n",
-    "prompt = hub.pull(\"hwchase17/xml-agent-convo\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "61ab3e9a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Logic for going from intermediate steps to a string to pass into model\n",
-    "# This is pretty tied to the prompt\n",
-    "def convert_intermediate_steps(intermediate_steps):\n",
-    "    log = \"\"\n",
-    "    for action, observation in intermediate_steps:\n",
-    "        log += (\n",
-    "            f\"<tool>{action.tool}</tool><tool_input>{action.tool_input}\"\n",
-    "            f\"</tool_input><observation>{observation}</observation>\"\n",
-    "        )\n",
-    "    return log\n",
-    "\n",
-    "\n",
-    "# Logic for converting tools to string to go in prompt\n",
-    "def convert_tools(tools):\n",
-    "    return \"\\n\".join([f\"{tool.name}: {tool.description}\" for tool in tools])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "260f5988",
-   "metadata": {},
-   "source": [
-    "Building an agent from a runnable usually involves a few things:\n",
-    "\n",
-    "1. Data processing for the intermediate steps. These need to be represented in a way that the language model can recognize them. This should be pretty tightly coupled to the instructions in the prompt\n",
-    "\n",
-    "2. The prompt itself\n",
-    "\n",
-    "3. The model, complete with stop tokens if needed\n",
-    "\n",
-    "4. The output parser - should be in sync with how the prompt specifies things to be formatted."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "e92f1d6f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "agent = (\n",
-    "    {\n",
-    "        \"input\": lambda x: x[\"input\"],\n",
-    "        \"agent_scratchpad\": lambda x: convert_intermediate_steps(\n",
-    "            x[\"intermediate_steps\"]\n",
-    "        ),\n",
-    "    }\n",
-    "    | prompt.partial(tools=convert_tools(tool_list))\n",
-    "    | model.bind(stop=[\"</tool_input>\", \"</final_answer>\"])\n",
-    "    | XMLAgentOutputParser()\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "6ce6ec7a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "agent_executor = AgentExecutor(agent=agent, tools=tool_list, verbose=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "fb5cb2e3",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
-      "\u001b[32;1m\u001b[1;3m <tool>search</tool><tool_input>weather in New York\u001b[0m\u001b[36;1m\u001b[1;3m32 degrees\u001b[0m\u001b[32;1m\u001b[1;3m <tool>search</tool>\n",
-      "<tool_input>weather in New York\u001b[0m\u001b[36;1m\u001b[1;3m32 degrees\u001b[0m\u001b[32;1m\u001b[1;3m <final_answer>The weather in New York is 32 degrees\u001b[0m\n",
-      "\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "{'input': 'whats the weather in New york?',\n",
-       " 'output': 'The weather in New York is 32 degrees'}"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "agent_executor.invoke({\"input\": \"whats the weather in New york?\"})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "bce86dd8",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "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.1"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/expression_language/cookbook/code_writing.ipynb

@@ -1,5 +1,15 @@
 {
  "cells": [
+  {
+   "cell_type": "raw",
+   "id": "1e997ab7",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "sidebar_class_name: hidden\n",
+    "---"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "f09fd305",

docs/docs/expression_language/cookbook/embedding_router.ipynb

@@ -1,163 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "cf4fb76d-c534-485b-8b51-a0714ee3b82e",
-   "metadata": {},
-   "source": [
-    "# Routing by semantic similarity\n",
-    "\n",
-    "With LCEL you can easily add [custom routing logic](/docs/expression_language/how_to/routing#using-a-custom-function) to your chain to dynamically determine the chain logic based on user input. All you need to do is define a function that given an input returns a `Runnable`.\n",
-    "\n",
-    "One especially useful technique is to use embeddings to route a query to the most relevant prompt. Here's a very simple example."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "b793a0aa",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%pip install --upgrade --quiet  langchain-core langchain langchain-openai"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "eef9020a-5f7c-4291-98eb-fa73f17d4b92",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.utils.math import cosine_similarity\n",
-    "from langchain_core.output_parsers import StrOutputParser\n",
-    "from langchain_core.prompts import PromptTemplate\n",
-    "from langchain_core.runnables import RunnableLambda, RunnablePassthrough\n",
-    "from langchain_openai import ChatOpenAI, OpenAIEmbeddings\n",
-    "\n",
-    "physics_template = \"\"\"You are a very smart physics professor. \\\n",
-    "You are great at answering questions about physics in a concise and easy to understand manner. \\\n",
-    "When you don't know the answer to a question you admit that you don't know.\n",
-    "\n",
-    "Here is a question:\n",
-    "{query}\"\"\"\n",
-    "\n",
-    "math_template = \"\"\"You are a very good mathematician. You are great at answering math questions. \\\n",
-    "You are so good because you are able to break down hard problems into their component parts, \\\n",
-    "answer the component parts, and then put them together to answer the broader question.\n",
-    "\n",
-    "Here is a question:\n",
-    "{query}\"\"\"\n",
-    "\n",
-    "embeddings = OpenAIEmbeddings()\n",
-    "prompt_templates = [physics_template, math_template]\n",
-    "prompt_embeddings = embeddings.embed_documents(prompt_templates)\n",
-    "\n",
-    "\n",
-    "def prompt_router(input):\n",
-    "    query_embedding = embeddings.embed_query(input[\"query\"])\n",
-    "    similarity = cosine_similarity([query_embedding], prompt_embeddings)[0]\n",
-    "    most_similar = prompt_templates[similarity.argmax()]\n",
-    "    print(\"Using MATH\" if most_similar == math_template else \"Using PHYSICS\")\n",
-    "    return PromptTemplate.from_template(most_similar)\n",
-    "\n",
-    "\n",
-    "chain = (\n",
-    "    {\"query\": RunnablePassthrough()}\n",
-    "    | RunnableLambda(prompt_router)\n",
-    "    | ChatOpenAI()\n",
-    "    | StrOutputParser()\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "4d22b0f3-24f2-4a47-9440-065b57ebcdbd",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Using PHYSICS\n",
-      "A black hole is a region in space where gravity is extremely strong, so strong that nothing, not even light, can escape its gravitational pull. It is formed when a massive star collapses under its own gravity during a supernova explosion. The collapse causes an incredibly dense mass to be concentrated in a small volume, creating a gravitational field that is so intense that it warps space and time. Black holes have a boundary called the event horizon, which marks the point of no return for anything that gets too close. Beyond the event horizon, the gravitational pull is so strong that even light cannot escape, hence the name \"black hole.\" While we have a good understanding of black holes, there is still much to learn, especially about what happens inside them.\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(chain.invoke(\"What's a black hole\"))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "f261910d-1de1-4a01-8c8a-308db02b81de",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Using MATH\n",
-      "Thank you for your kind words! I will do my best to break down the concept of a path integral for you.\n",
-      "\n",
-      "In mathematics and physics, a path integral is a mathematical tool used to calculate the probability amplitude or wave function of a particle or system of particles. It was introduced by Richard Feynman and is an integral over all possible paths that a particle can take to go from an initial state to a final state.\n",
-      "\n",
-      "To understand the concept better, let's consider an example. Suppose we have a particle moving from point A to point B in space. Classically, we would describe this particle's motion using a definite trajectory, but in quantum mechanics, particles can simultaneously take multiple paths from A to B.\n",
-      "\n",
-      "The path integral formalism considers all possible paths that the particle could take and assigns a probability amplitude to each path. These probability amplitudes are then added up, taking into account the interference effects between different paths.\n",
-      "\n",
-      "To calculate a path integral, we need to define an action, which is a mathematical function that describes the behavior of the system. The action is usually expressed in terms of the particle's position, velocity, and time.\n",
-      "\n",
-      "Once we have the action, we can write down the path integral as an integral over all possible paths. Each path is weighted by a factor determined by the action and the principle of least action, which states that a particle takes a path that minimizes the action.\n",
-      "\n",
-      "Mathematically, the path integral is expressed as:\n",
-      "\n",
-      "∫ e^(iS/ħ) D[x(t)]\n",
-      "\n",
-      "Here, S is the action, ħ is the reduced Planck's constant, and D[x(t)] represents the integration over all possible paths x(t) of the particle.\n",
-      "\n",
-      "By evaluating this integral, we can obtain the probability amplitude for the particle to go from the initial state to the final state. The absolute square of this amplitude gives us the probability of finding the particle in a particular state.\n",
-      "\n",
-      "Path integrals have proven to be a powerful tool in various areas of physics, including quantum mechanics, quantum field theory, and statistical mechanics. They allow us to study complex systems and calculate probabilities that are difficult to obtain using other methods.\n",
-      "\n",
-      "I hope this explanation helps you understand the concept of a path integral. If you have any further questions, feel free to ask!\n"
-     ]
-    }
-   ],
-   "source": [
-    "print(chain.invoke(\"What's a path integral\"))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "f0c1732a-01ca-4d10-977c-29ed7480972b",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "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.9.1"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/expression_language/cookbook/index.mdx

@@ -1,11 +0,0 @@
----
-sidebar_position: 3
----
-
-# Cookbook
-
-import DocCardList from "@theme/DocCardList";
-
-Example code for accomplishing common tasks with the LangChain Expression Language (LCEL). These examples show how to compose different Runnable (the core LCEL interface) components to achieve various tasks. If you're just getting acquainted with LCEL, the [Prompt + LLM](/docs/expression_language/cookbook/prompt_llm_parser) page is a good place to start.
-
-<DocCardList />

docs/docs/expression_language/cookbook/memory.ipynb

@@ -1,194 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "5062941a",
-   "metadata": {},
-   "source": [
-    "# Adding memory\n",
-    "\n",
-    "This shows how to add memory to an arbitrary chain. Right now, you can use the memory classes but need to hook it up manually"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "18753dee",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%pip install --upgrade --quiet  langchain langchain-openai"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "7998efd8",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from operator import itemgetter\n",
-    "\n",
-    "from langchain.memory import ConversationBufferMemory\n",
-    "from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n",
-    "from langchain_core.runnables import RunnableLambda, RunnablePassthrough\n",
-    "from langchain_openai import ChatOpenAI\n",
-    "\n",
-    "model = ChatOpenAI()\n",
-    "prompt = ChatPromptTemplate.from_messages(\n",
-    "    [\n",
-    "        (\"system\", \"You are a helpful chatbot\"),\n",
-    "        MessagesPlaceholder(variable_name=\"history\"),\n",
-    "        (\"human\", \"{input}\"),\n",
-    "    ]\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "fa0087f3",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "memory = ConversationBufferMemory(return_messages=True)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "06b531ae",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'history': []}"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "memory.load_memory_variables({})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "d9437af6",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "chain = (\n",
-    "    RunnablePassthrough.assign(\n",
-    "        history=RunnableLambda(memory.load_memory_variables) | itemgetter(\"history\")\n",
-    "    )\n",
-    "    | prompt\n",
-    "    | model\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "bed1e260",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "AIMessage(content='Hello Bob! How can I assist you today?', additional_kwargs={}, example=False)"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "inputs = {\"input\": \"hi im bob\"}\n",
-    "response = chain.invoke(inputs)\n",
-    "response"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "890475b4",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "memory.save_context(inputs, {\"output\": response.content})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "e8fcb77f",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'history': [HumanMessage(content='hi im bob', additional_kwargs={}, example=False),\n",
-       "  AIMessage(content='Hello Bob! How can I assist you today?', additional_kwargs={}, example=False)]}"
-      ]
-     },
-     "execution_count": 7,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "memory.load_memory_variables({})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "d837d5c3",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "AIMessage(content='Your name is Bob.', additional_kwargs={}, example=False)"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "inputs = {\"input\": \"whats my name\"}\n",
-    "response = chain.invoke(inputs)\n",
-    "response"
-   ]
-  }
- ],
- "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.9.1"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/expression_language/cookbook/multiple_chains.ipynb

@@ -20,9 +20,11 @@
    ]
   },
   {
-   "cell_type": "raw",
+   "cell_type": "code",
    "id": "0f316b5c",
+   "execution_count": null,
    "metadata": {},
+   "outputs": [],
    "source": [
     "%pip install --upgrade --quiet  langchain langchain-openai"
    ]

docs/docs/expression_language/cookbook/prompt_size.ipynb

@@ -34,7 +34,7 @@
     "from langchain.agents import AgentExecutor, load_tools\n",
     "from langchain.agents.format_scratchpad import format_to_openai_function_messages\n",
     "from langchain.agents.output_parsers import OpenAIFunctionsAgentOutputParser\n",
-    "from langchain.tools import WikipediaQueryRun\n",
+    "from langchain_community.tools import WikipediaQueryRun\n",
     "from langchain_community.utilities import WikipediaAPIWrapper\n",
     "from langchain_core.prompt_values import ChatPromptValue\n",
     "from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n",
@@ -220,7 +220,7 @@
    "id": "637f994a-5134-402a-bcf0-4de3911eaf49",
    "metadata": {},
    "source": [
-    ":::tip\n",
+    ":::{.callout-tip}\n",
     "\n",
     "[LangSmith trace](https://smith.langchain.com/public/60909eae-f4f1-43eb-9f96-354f5176f66f/r)\n",
     "\n",
@@ -388,7 +388,7 @@
    "id": "5a7e498b-dc68-4267-a35c-90ceffa91c46",
    "metadata": {},
    "source": [
-    ":::tip\n",
+    ":::{.callout-tip}\n",
     "\n",
     "[LangSmith trace](https://smith.langchain.com/public/3b27d47f-e4df-4afb-81b1-0f88b80ca97e/r)\n",
     "\n",

docs/docs/expression_language/cookbook/retrieval.ipynb

@@ -1,492 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "raw",
-   "id": "abe47592-909c-4844-bf44-9e55c2fb4bfa",
-   "metadata": {},
-   "source": [
-    "---\n",
-    "sidebar_position: 1\n",
-    "title: RAG\n",
-    "---\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "91c5ef3d",
-   "metadata": {},
-   "source": [
-    "Let's look at adding in a retrieval step to a prompt and LLM, which adds up to a \"retrieval-augmented generation\" chain"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "7f25d9e9-d192-42e9-af50-5660a4bfb0d9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%pip install --upgrade --quiet  langchain langchain-openai faiss-cpu tiktoken"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "33be32af",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from operator import itemgetter\n",
-    "\n",
-    "from langchain_community.vectorstores import FAISS\n",
-    "from langchain_core.output_parsers import StrOutputParser\n",
-    "from langchain_core.prompts import ChatPromptTemplate\n",
-    "from langchain_core.runnables import RunnableLambda, RunnablePassthrough\n",
-    "from langchain_openai import ChatOpenAI, OpenAIEmbeddings"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "bfc47ec1",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "vectorstore = FAISS.from_texts(\n",
-    "    [\"harrison worked at kensho\"], embedding=OpenAIEmbeddings()\n",
-    ")\n",
-    "retriever = vectorstore.as_retriever()\n",
-    "\n",
-    "template = \"\"\"Answer the question based only on the following context:\n",
-    "{context}\n",
-    "\n",
-    "Question: {question}\n",
-    "\"\"\"\n",
-    "prompt = ChatPromptTemplate.from_template(template)\n",
-    "\n",
-    "model = ChatOpenAI()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "eae31755",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "chain = (\n",
-    "    {\"context\": retriever, \"question\": RunnablePassthrough()}\n",
-    "    | prompt\n",
-    "    | model\n",
-    "    | StrOutputParser()\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "f3040b0c",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'Harrison worked at Kensho.'"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "chain.invoke(\"where did harrison work?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "e1d20c7c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "template = \"\"\"Answer the question based only on the following context:\n",
-    "{context}\n",
-    "\n",
-    "Question: {question}\n",
-    "\n",
-    "Answer in the following language: {language}\n",
-    "\"\"\"\n",
-    "prompt = ChatPromptTemplate.from_template(template)\n",
-    "\n",
-    "chain = (\n",
-    "    {\n",
-    "        \"context\": itemgetter(\"question\") | retriever,\n",
-    "        \"question\": itemgetter(\"question\"),\n",
-    "        \"language\": itemgetter(\"language\"),\n",
-    "    }\n",
-    "    | prompt\n",
-    "    | model\n",
-    "    | StrOutputParser()\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "7ee8b2d4",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'Harrison ha lavorato a Kensho.'"
-      ]
-     },
-     "execution_count": 6,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "chain.invoke({\"question\": \"where did harrison work\", \"language\": \"italian\"})"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "f007669c",
-   "metadata": {},
-   "source": [
-    "## Conversational Retrieval Chain\n",
-    "\n",
-    "We can easily add in conversation history. This primarily means adding in chat_message_history"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "id": "3f30c348",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_core.messages import AIMessage, HumanMessage, get_buffer_string\n",
-    "from langchain_core.prompts import format_document\n",
-    "from langchain_core.runnables import RunnableParallel"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "64ab1dbf",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.prompts.prompt import PromptTemplate\n",
-    "\n",
-    "_template = \"\"\"Given the following conversation and a follow up question, rephrase the follow up question to be a standalone question, in its original language.\n",
-    "\n",
-    "Chat History:\n",
-    "{chat_history}\n",
-    "Follow Up Input: {question}\n",
-    "Standalone question:\"\"\"\n",
-    "CONDENSE_QUESTION_PROMPT = PromptTemplate.from_template(_template)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "7d628c97",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "template = \"\"\"Answer the question based only on the following context:\n",
-    "{context}\n",
-    "\n",
-    "Question: {question}\n",
-    "\"\"\"\n",
-    "ANSWER_PROMPT = ChatPromptTemplate.from_template(template)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "f60a5d0f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "DEFAULT_DOCUMENT_PROMPT = PromptTemplate.from_template(template=\"{page_content}\")\n",
-    "\n",
-    "\n",
-    "def _combine_documents(\n",
-    "    docs, document_prompt=DEFAULT_DOCUMENT_PROMPT, document_separator=\"\\n\\n\"\n",
-    "):\n",
-    "    doc_strings = [format_document(doc, document_prompt) for doc in docs]\n",
-    "    return document_separator.join(doc_strings)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "5c32cc89",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "_inputs = RunnableParallel(\n",
-    "    standalone_question=RunnablePassthrough.assign(\n",
-    "        chat_history=lambda x: get_buffer_string(x[\"chat_history\"])\n",
-    "    )\n",
-    "    | CONDENSE_QUESTION_PROMPT\n",
-    "    | ChatOpenAI(temperature=0)\n",
-    "    | StrOutputParser(),\n",
-    ")\n",
-    "_context = {\n",
-    "    \"context\": itemgetter(\"standalone_question\") | retriever | _combine_documents,\n",
-    "    \"question\": lambda x: x[\"standalone_question\"],\n",
-    "}\n",
-    "conversational_qa_chain = _inputs | _context | ANSWER_PROMPT | ChatOpenAI()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "135c8205",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "AIMessage(content='Harrison was employed at Kensho.')"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversational_qa_chain.invoke(\n",
-    "    {\n",
-    "        \"question\": \"where did harrison work?\",\n",
-    "        \"chat_history\": [],\n",
-    "    }\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "id": "424e7e7a",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "AIMessage(content='Harrison worked at Kensho.')"
-      ]
-     },
-     "execution_count": 22,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "conversational_qa_chain.invoke(\n",
-    "    {\n",
-    "        \"question\": \"where did he work?\",\n",
-    "        \"chat_history\": [\n",
-    "            HumanMessage(content=\"Who wrote this notebook?\"),\n",
-    "            AIMessage(content=\"Harrison\"),\n",
-    "        ],\n",
-    "    }\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c5543183",
-   "metadata": {},
-   "source": [
-    "### With Memory and returning source documents\n",
-    "\n",
-    "This shows how to use memory with the above. For memory, we need to manage that outside at the memory. For returning the retrieved documents, we just need to pass them through all the way."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "e31dd17c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from operator import itemgetter\n",
-    "\n",
-    "from langchain.memory import ConversationBufferMemory"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "d4bffe94",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "memory = ConversationBufferMemory(\n",
-    "    return_messages=True, output_key=\"answer\", input_key=\"question\"\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "id": "733be985",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# First we add a step to load memory\n",
-    "# This adds a \"memory\" key to the input object\n",
-    "loaded_memory = RunnablePassthrough.assign(\n",
-    "    chat_history=RunnableLambda(memory.load_memory_variables) | itemgetter(\"history\"),\n",
-    ")\n",
-    "# Now we calculate the standalone question\n",
-    "standalone_question = {\n",
-    "    \"standalone_question\": {\n",
-    "        \"question\": lambda x: x[\"question\"],\n",
-    "        \"chat_history\": lambda x: get_buffer_string(x[\"chat_history\"]),\n",
-    "    }\n",
-    "    | CONDENSE_QUESTION_PROMPT\n",
-    "    | ChatOpenAI(temperature=0)\n",
-    "    | StrOutputParser(),\n",
-    "}\n",
-    "# Now we retrieve the documents\n",
-    "retrieved_documents = {\n",
-    "    \"docs\": itemgetter(\"standalone_question\") | retriever,\n",
-    "    \"question\": lambda x: x[\"standalone_question\"],\n",
-    "}\n",
-    "# Now we construct the inputs for the final prompt\n",
-    "final_inputs = {\n",
-    "    \"context\": lambda x: _combine_documents(x[\"docs\"]),\n",
-    "    \"question\": itemgetter(\"question\"),\n",
-    "}\n",
-    "# And finally, we do the part that returns the answers\n",
-    "answer = {\n",
-    "    \"answer\": final_inputs | ANSWER_PROMPT | ChatOpenAI(),\n",
-    "    \"docs\": itemgetter(\"docs\"),\n",
-    "}\n",
-    "# And now we put it all together!\n",
-    "final_chain = loaded_memory | standalone_question | retrieved_documents | answer"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "806e390c",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'answer': AIMessage(content='Harrison was employed at Kensho.'),\n",
-       " 'docs': [Document(page_content='harrison worked at kensho')]}"
-      ]
-     },
-     "execution_count": 17,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "inputs = {\"question\": \"where did harrison work?\"}\n",
-    "result = final_chain.invoke(inputs)\n",
-    "result"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "id": "977399fd",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Note that the memory does not save automatically\n",
-    "# This will be improved in the future\n",
-    "# For now you need to save it yourself\n",
-    "memory.save_context(inputs, {\"answer\": result[\"answer\"].content})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "id": "f94f7de4",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'history': [HumanMessage(content='where did harrison work?'),\n",
-       "  AIMessage(content='Harrison was employed at Kensho.')]}"
-      ]
-     },
-     "execution_count": 19,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "memory.load_memory_variables({})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "id": "88f2b7cd",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'answer': AIMessage(content='Harrison actually worked at Kensho.'),\n",
-       " 'docs': [Document(page_content='harrison worked at kensho')]}"
-      ]
-     },
-     "execution_count": 20,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "inputs = {\"question\": \"but where did he really work?\"}\n",
-    "result = final_chain.invoke(inputs)\n",
-    "result"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "207a2782",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "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.1"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/expression_language/cookbook/sql_db.ipynb

@@ -1,223 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "raw",
-   "id": "c14da114-1a4a-487d-9cff-e0e8c30ba366",
-   "metadata": {},
-   "source": [
-    "---\n",
-    "sidebar_position: 3\n",
-    "title: Querying a SQL DB\n",
-    "---\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "506e9636",
-   "metadata": {},
-   "source": [
-    "We can replicate our SQLDatabaseChain with Runnables."
-   ]
-  },
-  {
-   "cell_type": "raw",
-   "id": "b3121aa8",
-   "metadata": {},
-   "source": [
-    "%pip install --upgrade --quiet  langchain langchain-openai"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "7a927516",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_core.prompts import ChatPromptTemplate\n",
-    "\n",
-    "template = \"\"\"Based on the table schema below, write a SQL query that would answer the user's question:\n",
-    "{schema}\n",
-    "\n",
-    "Question: {question}\n",
-    "SQL Query:\"\"\"\n",
-    "prompt = ChatPromptTemplate.from_template(template)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "3f51f386",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_community.utilities import SQLDatabase"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "7c3449d6-684b-416e-ba16-90a035835a88",
-   "metadata": {},
-   "source": [
-    "We'll need the Chinook sample DB for this example. There's many places to download it from, e.g. https://database.guide/2-sample-databases-sqlite/"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "id": "2ccca6fc",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "db = SQLDatabase.from_uri(\"sqlite:///./Chinook.db\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "id": "05ba88ee",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def get_schema(_):\n",
-    "    return db.get_table_info()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "id": "a4eda902",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def run_query(query):\n",
-    "    return db.run(query)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "id": "5046cb17",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_core.output_parsers import StrOutputParser\n",
-    "from langchain_core.runnables import RunnablePassthrough\n",
-    "from langchain_openai import ChatOpenAI\n",
-    "\n",
-    "model = ChatOpenAI()\n",
-    "\n",
-    "sql_response = (\n",
-    "    RunnablePassthrough.assign(schema=get_schema)\n",
-    "    | prompt\n",
-    "    | model.bind(stop=[\"\\nSQLResult:\"])\n",
-    "    | StrOutputParser()\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "id": "a5552039",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'SELECT COUNT(*) FROM Employee'"
-      ]
-     },
-     "execution_count": 24,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "sql_response.invoke({\"question\": \"How many employees are there?\"})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "id": "d6fee130",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "template = \"\"\"Based on the table schema below, question, sql query, and sql response, write a natural language response:\n",
-    "{schema}\n",
-    "\n",
-    "Question: {question}\n",
-    "SQL Query: {query}\n",
-    "SQL Response: {response}\"\"\"\n",
-    "prompt_response = ChatPromptTemplate.from_template(template)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "id": "923aa634",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "full_chain = (\n",
-    "    RunnablePassthrough.assign(query=sql_response).assign(\n",
-    "        schema=get_schema,\n",
-    "        response=lambda x: db.run(x[\"query\"]),\n",
-    "    )\n",
-    "    | prompt_response\n",
-    "    | model\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 27,
-   "id": "e94963d8",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "AIMessage(content='There are 8 employees.', additional_kwargs={}, example=False)"
-      ]
-     },
-     "execution_count": 27,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "full_chain.invoke({\"question\": \"How many employees are there?\"})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "4f358d7b-a721-4db3-9f92-f06913428afc",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "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.9.1"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/expression_language/cookbook/tools.ipynb

@@ -1,122 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "29781123",
-   "metadata": {},
-   "source": [
-    "# Using tools\n",
-    "\n",
-    "You can use any Tools with Runnables easily."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "a5c579dd-2e22-41b0-a789-346dfdecb5a2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%pip install --upgrade --quiet  langchain langchain-openai duckduckgo-search"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "9232d2a9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.tools import DuckDuckGoSearchRun\n",
-    "from langchain_core.output_parsers import StrOutputParser\n",
-    "from langchain_core.prompts import ChatPromptTemplate\n",
-    "from langchain_openai import ChatOpenAI"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "a0c64d2c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "search = DuckDuckGoSearchRun()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "391969b6",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "template = \"\"\"turn the following user input into a search query for a search engine:\n",
-    "\n",
-    "{input}\"\"\"\n",
-    "prompt = ChatPromptTemplate.from_template(template)\n",
-    "\n",
-    "model = ChatOpenAI()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "e3d9d20d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "chain = prompt | model | StrOutputParser() | search"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "55f2967d",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'What sports games are on TV today & tonight? Watch and stream live sports on TV today, tonight, tomorrow. Today\\'s 2023 sports TV schedule includes football, basketball, baseball, hockey, motorsports, soccer and more. Watch on TV or stream online on ESPN, FOX, FS1, CBS, NBC, ABC, Peacock, Paramount+, fuboTV, local channels and many other networks. MLB Games Tonight: How to Watch on TV, Streaming & Odds - Thursday, September 7. Seattle Mariners\\' Julio Rodriguez greets teammates in the dugout after scoring against the Oakland Athletics in a ... Circle - Country Music and Lifestyle. Live coverage of all the MLB action today is available to you, with the information provided below. The Brewers will look to pick up a road win at PNC Park against the Pirates on Wednesday at 12:35 PM ET. Check out the latest odds and with BetMGM Sportsbook. Use bonus code \"GNPLAY\" for special offers! MLB Games Tonight: How to Watch on TV, Streaming & Odds - Tuesday, September 5. Houston Astros\\' Kyle Tucker runs after hitting a double during the fourth inning of a baseball game against the Los Angeles Angels, Sunday, Aug. 13, 2023, in Houston. (AP Photo/Eric Christian Smith) (APMedia) The Houston Astros versus the Texas Rangers is one of ... The second half of tonight\\'s college football schedule still has some good games remaining to watch on your television.. We\\'ve already seen an exciting one when Colorado upset TCU. And we saw some ...'"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "chain.invoke({\"input\": \"I'd like to figure out what games are tonight\"})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "a16949cf-00ea-43c6-a6aa-797ad4f6918d",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "poetry-venv",
-   "language": "python",
-   "name": "poetry-venv"
-  },
-  "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.1"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/expression_language/get_started.ipynb

@@ -40,6 +40,33 @@
     "%pip install --upgrade --quiet  langchain-core langchain-community langchain-openai"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "c3d54f72",
+   "metadata": {},
+   "source": [
+    "```{=mdx}\n",
+    "import ChatModelTabs from \"@theme/ChatModelTabs\";\n",
+    "\n",
+    "<ChatModelTabs openaiParams={`model=\"gpt-4\"`} />\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f9eed8e8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# | output: false\n",
+    "# | echo: false\n",
+    "\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "\n",
+    "model = ChatOpenAI(model=\"gpt-4\")"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -60,10 +87,8 @@
    "source": [
     "from langchain_core.output_parsers import StrOutputParser\n",
     "from langchain_core.prompts import ChatPromptTemplate\n",
-    "from langchain_openai import ChatOpenAI\n",
     "\n",
     "prompt = ChatPromptTemplate.from_template(\"tell me a short joke about {topic}\")\n",
-    "model = ChatOpenAI(model=\"gpt-4\")\n",
     "output_parser = StrOutputParser()\n",
     "\n",
     "chain = prompt | model | output_parser\n",
@@ -76,15 +101,15 @@
    "id": "81c502c5-85ee-4f36-aaf4-d6e350b7792f",
    "metadata": {},
    "source": [
-    "Notice this line of this code, where we piece together then different components into a single chain using LCEL:\n",
+    "Notice this line of the code, where we piece together these different components into a single chain using LCEL:\n",
     "\n",
     "```\n",
     "chain = prompt | model | output_parser\n",
     "```\n",
     "\n",
-    "The `|` symbol is similar to a [unix pipe operator](https://en.wikipedia.org/wiki/Pipeline_(Unix)), which chains together the different components feeds the output from one component as input into the next component. \n",
+    "The `|` symbol is similar to a [unix pipe operator](https://en.wikipedia.org/wiki/Pipeline_(Unix)), which chains together the different components, feeding the output from one component as input into the next component. \n",
     "\n",
-    "In this chain the user input is passed to the prompt template, then the prompt template output is passed to the model, then the model output is passed to the output parser. Let's take a look at each component individually to really understand what's going on. "
+    "In this chain the user input is passed to the prompt template, then the prompt template output is passed to the model, then the model output is passed to the output parser. Let's take a look at each component individually to really understand what's going on."
    ]
   },
   {
@@ -219,7 +244,7 @@
     }
    ],
    "source": [
-    "from langchain_openai.llms import OpenAI\n",
+    "from langchain_openai import OpenAI\n",
     "\n",
     "llm = OpenAI(model=\"gpt-3.5-turbo-instruct\")\n",
     "llm.invoke(prompt_value)"
@@ -233,7 +258,7 @@
     "### 3. Output parser\n",
     "\n",
     "And lastly we pass our `model` output to the `output_parser`, which is a `BaseOutputParser` meaning it takes either a string or a \n",
-    "`BaseMessage` as input. The `StrOutputParser` specifically simple converts any input into a string."
+    "`BaseMessage` as input. The specific `StrOutputParser` simply converts any input into a string."
    ]
   },
   {
@@ -293,7 +318,7 @@
    "source": [
     ":::info\n",
     "\n",
-    "Note that if you’re curious about the output of any components, you can always test out a smaller version of the chain such as `prompt`  or `prompt | model` to see the intermediate results:\n",
+    "Note that if you’re curious about the output of any components, you can always test out a smaller version of the chain such as `prompt` or `prompt | model` to see the intermediate results:\n",
     "\n",
     ":::"
    ]
@@ -321,7 +346,17 @@
    "source": [
     "## RAG Search Example\n",
     "\n",
-    "For our next example, we want to run a retrieval-augmented generation chain to add some context when responding to questions. "
+    "For our next example, we want to run a retrieval-augmented generation chain to add some context when responding to questions."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b8fe8eb4",
+   "metadata": {},
+   "source": [
+    "```{=mdx}\n",
+    "<ChatModelTabs />\n",
+    "```"
    ]
   },
   {
@@ -338,8 +373,7 @@
     "from langchain_core.output_parsers import StrOutputParser\n",
     "from langchain_core.prompts import ChatPromptTemplate\n",
     "from langchain_core.runnables import RunnableParallel, RunnablePassthrough\n",
-    "from langchain_openai.chat_models import ChatOpenAI\n",
-    "from langchain_openai.embeddings import OpenAIEmbeddings\n",
+    "from langchain_openai import OpenAIEmbeddings\n",
     "\n",
     "vectorstore = DocArrayInMemorySearch.from_texts(\n",
     "    [\"harrison worked at kensho\", \"bears like to eat honey\"],\n",
@@ -353,7 +387,6 @@
     "Question: {question}\n",
     "\"\"\"\n",
     "prompt = ChatPromptTemplate.from_template(template)\n",
-    "model = ChatOpenAI()\n",
     "output_parser = StrOutputParser()\n",
     "\n",
     "setup_and_retrieval = RunnableParallel(\n",
@@ -407,7 +440,7 @@
    "id": "e6833844-f1c4-444c-a3d2-31b3c6b31d46",
    "metadata": {},
    "source": [
-    "We then use the `RunnableParallel` to prepare the expected inputs into the prompt by using the entries for the retrieved documents as well as the original user question, using the retriever for document search, and RunnablePassthrough to pass the user’s question:"
+    "We then use the `RunnableParallel` to prepare the expected inputs into the prompt by using the entries for the retrieved documents as well as the original user question, using the retriever for document search, and `RunnablePassthrough` to pass the user’s question:"
    ]
   },
   {
@@ -451,7 +484,7 @@
     "With the flow being:\n",
     "\n",
     "1. The first steps create a `RunnableParallel` object with two entries.  The first entry, `context` will include the document results fetched by the retriever. The second entry, `question` will contain the user’s original question. To pass on the question, we use `RunnablePassthrough` to copy this entry. \n",
-    "2. Feed the dictionary from the step above to the `prompt` component. It then takes the user input which is `question` as well as the retrieved document which is `context` to construct a prompt and output a PromptValue.  \n",
+    "2. Feed the dictionary from the step above to the `prompt` component. It then takes the user input which is `question` as well as the retrieved document which is `context` to construct a prompt and output a PromptValue. \n",
     "3. The `model` component takes the generated prompt, and passes into the OpenAI LLM model for evaluation. The generated output from the model is a `ChatMessage` object. \n",
     "4. Finally, the `output_parser` component takes in a `ChatMessage`, and transforms this into a Python string, which is returned from the invoke method.\n",
     "\n",
@@ -476,7 +509,7 @@
    "source": [
     "## Next steps\n",
     "\n",
-    "We recommend reading our [Why use LCEL](/docs/expression_language/why) section next to see a side-by-side comparison of the code needed to produce common functionality with and without LCEL."
+    "We recommend reading our [Advantages of LCEL](/docs/expression_language/why) section next to see a side-by-side comparison of the code needed to produce common functionality with and without LCEL."
    ]
   }
  ],
@@ -496,7 +529,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.4"
+   "version": "3.11.0"
   }
  },
  "nbformat": 4,

docs/docs/expression_language/how_to/decorator.ipynb

@@ -5,9 +5,9 @@
    "id": "b45110ef",
    "metadata": {},
    "source": [
-    "# Create a runnable with the `@chain` decorator\n",
+    "# Create a runnable with the @chain decorator\n",
     "\n",
-    "You can also turn an arbitrary function into a chain by adding a `@chain` decorator. This is functionaly equivalent to wrapping in a [`RunnableLambda`](./functions).\n",
+    "You can also turn an arbitrary function into a chain by adding a `@chain` decorator. This is functionaly equivalent to wrapping in a [`RunnableLambda`](/docs/expression_language/primitives/functions).\n",
     "\n",
     "This will have the benefit of improved observability by tracing your chain correctly. Any calls to runnables inside this function will be traced as nested childen.\n",
     "\n",

docs/docs/expression_language/how_to/fallbacks.ipynb

@@ -1,310 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "19c9cbd6",
-   "metadata": {},
-   "source": [
-    "# Add fallbacks\n",
-    "\n",
-    "There are many possible points of failure in an LLM application, whether that be issues with LLM API's, poor model outputs, issues with other integrations, etc. Fallbacks help you gracefully handle and isolate these issues.\n",
-    "\n",
-    "Crucially, fallbacks can be applied not only on the LLM level but on the whole runnable level."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "a6bb9ba9",
-   "metadata": {},
-   "source": [
-    "## Handling LLM API Errors\n",
-    "\n",
-    "This is maybe the most common use case for fallbacks. A request to an LLM API can fail for a variety of reasons - the API could be down, you could have hit rate limits, any number of things. Therefore, using fallbacks can help protect against these types of things.\n",
-    "\n",
-    "IMPORTANT: By default, a lot of the LLM wrappers catch errors and retry. You will most likely want to turn those off when working with fallbacks. Otherwise the first wrapper will keep on retrying and not failing."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ebb61b1f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%pip install --upgrade --quiet  langchain langchain-openai"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "d3e893bf",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_community.chat_models import ChatAnthropic\n",
-    "from langchain_openai import ChatOpenAI"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "4847c82d",
-   "metadata": {},
-   "source": [
-    "First, let's mock out what happens if we hit a RateLimitError from OpenAI"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "dfdd8bf5",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from unittest.mock import patch\n",
-    "\n",
-    "import httpx\n",
-    "from openai import RateLimitError\n",
-    "\n",
-    "request = httpx.Request(\"GET\", \"/\")\n",
-    "response = httpx.Response(200, request=request)\n",
-    "error = RateLimitError(\"rate limit\", response=response, body=\"\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "e6fdffc1",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Note that we set max_retries = 0 to avoid retrying on RateLimits, etc\n",
-    "openai_llm = ChatOpenAI(max_retries=0)\n",
-    "anthropic_llm = ChatAnthropic()\n",
-    "llm = openai_llm.with_fallbacks([anthropic_llm])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "584461ab",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Hit error\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Let's use just the OpenAI LLm first, to show that we run into an error\n",
-    "with patch(\"openai.resources.chat.completions.Completions.create\", side_effect=error):\n",
-    "    try:\n",
-    "        print(openai_llm.invoke(\"Why did the chicken cross the road?\"))\n",
-    "    except RateLimitError:\n",
-    "        print(\"Hit error\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 28,
-   "id": "4fc1e673",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "content=' I don\\'t actually know why the chicken crossed the road, but here are some possible humorous answers:\\n\\n- To get to the other side!\\n\\n- It was too chicken to just stand there. \\n\\n- It wanted a change of scenery.\\n\\n- It wanted to show the possum it could be done.\\n\\n- It was on its way to a poultry farmers\\' convention.\\n\\nThe joke plays on the double meaning of \"the other side\" - literally crossing the road to the other side, or the \"other side\" meaning the afterlife. So it\\'s an anti-joke, with a silly or unexpected pun as the answer.' additional_kwargs={} example=False\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Now let's try with fallbacks to Anthropic\n",
-    "with patch(\"openai.resources.chat.completions.Completions.create\", side_effect=error):\n",
-    "    try:\n",
-    "        print(llm.invoke(\"Why did the chicken cross the road?\"))\n",
-    "    except RateLimitError:\n",
-    "        print(\"Hit error\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "f00bea25",
-   "metadata": {},
-   "source": [
-    "We can use our \"LLM with Fallbacks\" as we would a normal LLM."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "4f8eaaa0",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "content=\" I don't actually know why the kangaroo crossed the road, but I'm happy to take a guess! Maybe the kangaroo was trying to get to the other side to find some tasty grass to eat. Or maybe it was trying to get away from a predator or other danger. Kangaroos do need to cross roads and other open areas sometimes as part of their normal activities. Whatever the reason, I'm sure the kangaroo looked both ways before hopping across!\" additional_kwargs={} example=False\n"
-     ]
-    }
-   ],
-   "source": [
-    "from langchain_core.prompts import ChatPromptTemplate\n",
-    "\n",
-    "prompt = ChatPromptTemplate.from_messages(\n",
-    "    [\n",
-    "        (\n",
-    "            \"system\",\n",
-    "            \"You're a nice assistant who always includes a compliment in your response\",\n",
-    "        ),\n",
-    "        (\"human\", \"Why did the {animal} cross the road\"),\n",
-    "    ]\n",
-    ")\n",
-    "chain = prompt | llm\n",
-    "with patch(\"openai.resources.chat.completions.Completions.create\", side_effect=error):\n",
-    "    try:\n",
-    "        print(chain.invoke({\"animal\": \"kangaroo\"}))\n",
-    "    except RateLimitError:\n",
-    "        print(\"Hit error\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "ef9f0f39-0b9f-4723-a394-f61c98c75d41",
-   "metadata": {},
-   "source": [
-    "### Specifying errors to handle\n",
-    "\n",
-    "We can also specify the errors to handle if we want to be more specific about when the fallback is invoked:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "e4069ca4-1c16-4915-9a8c-b2732869ae27",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Hit error\n"
-     ]
-    }
-   ],
-   "source": [
-    "llm = openai_llm.with_fallbacks(\n",
-    "    [anthropic_llm], exceptions_to_handle=(KeyboardInterrupt,)\n",
-    ")\n",
-    "\n",
-    "chain = prompt | llm\n",
-    "with patch(\"openai.resources.chat.completions.Completions.create\", side_effect=error):\n",
-    "    try:\n",
-    "        print(chain.invoke({\"animal\": \"kangaroo\"}))\n",
-    "    except RateLimitError:\n",
-    "        print(\"Hit error\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "8d62241b",
-   "metadata": {},
-   "source": [
-    "## Fallbacks for Sequences\n",
-    "\n",
-    "We can also create fallbacks for sequences, that are sequences themselves. Here we do that with two different models: ChatOpenAI and then normal OpenAI (which does not use a chat model). Because OpenAI is NOT a chat model, you likely want a different prompt."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 30,
-   "id": "6d0b8056",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# First let's create a chain with a ChatModel\n",
-    "# We add in a string output parser here so the outputs between the two are the same type\n",
-    "from langchain_core.output_parsers import StrOutputParser\n",
-    "\n",
-    "chat_prompt = ChatPromptTemplate.from_messages(\n",
-    "    [\n",
-    "        (\n",
-    "            \"system\",\n",
-    "            \"You're a nice assistant who always includes a compliment in your response\",\n",
-    "        ),\n",
-    "        (\"human\", \"Why did the {animal} cross the road\"),\n",
-    "    ]\n",
-    ")\n",
-    "# Here we're going to use a bad model name to easily create a chain that will error\n",
-    "chat_model = ChatOpenAI(model_name=\"gpt-fake\")\n",
-    "bad_chain = chat_prompt | chat_model | StrOutputParser()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 31,
-   "id": "8d1fc2a5",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Now lets create a chain with the normal OpenAI model\n",
-    "from langchain.prompts import PromptTemplate\n",
-    "from langchain_openai import OpenAI\n",
-    "\n",
-    "prompt_template = \"\"\"Instructions: You should always include a compliment in your response.\n",
-    "\n",
-    "Question: Why did the {animal} cross the road?\"\"\"\n",
-    "prompt = PromptTemplate.from_template(prompt_template)\n",
-    "llm = OpenAI()\n",
-    "good_chain = prompt | llm"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "id": "283bfa44",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'\\n\\nAnswer: The turtle crossed the road to get to the other side, and I have to say he had some impressive determination.'"
-      ]
-     },
-     "execution_count": 32,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "# We can now create a final chain which combines the two\n",
-    "chain = bad_chain.with_fallbacks([good_chain])\n",
-    "chain.invoke({\"animal\": \"turtle\"})"
-   ]
-  }
- ],
- "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.9.1"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/expression_language/how_to/functions.ipynb

@@ -1,206 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "raw",
-   "id": "ce0e08fd",
-   "metadata": {},
-   "source": [
-    "---\n",
-    "sidebar_position: 2\n",
-    "title: \"RunnableLambda: Run Custom Functions\"\n",
-    "keywords: [RunnableLambda, LCEL]\n",
-    "---"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "fbc4bf6e",
-   "metadata": {},
-   "source": [
-    "# Run custom functions\n",
-    "\n",
-    "You can use arbitrary functions in the pipeline.\n",
-    "\n",
-    "Note that all inputs to these functions need to be a SINGLE argument. If you have a function that accepts multiple arguments, you should write a wrapper that accepts a single input and unpacks it into multiple argument."
-   ]
-  },
-  {
-   "cell_type": "raw",
-   "id": "9a5fe916",
-   "metadata": {},
-   "source": [
-    "%pip install --upgrade --quiet  langchain langchain-openai"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "6bb221b3",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from operator import itemgetter\n",
-    "\n",
-    "from langchain_core.prompts import ChatPromptTemplate\n",
-    "from langchain_core.runnables import RunnableLambda\n",
-    "from langchain_openai import ChatOpenAI\n",
-    "\n",
-    "\n",
-    "def length_function(text):\n",
-    "    return len(text)\n",
-    "\n",
-    "\n",
-    "def _multiple_length_function(text1, text2):\n",
-    "    return len(text1) * len(text2)\n",
-    "\n",
-    "\n",
-    "def multiple_length_function(_dict):\n",
-    "    return _multiple_length_function(_dict[\"text1\"], _dict[\"text2\"])\n",
-    "\n",
-    "\n",
-    "prompt = ChatPromptTemplate.from_template(\"what is {a} + {b}\")\n",
-    "model = ChatOpenAI()\n",
-    "\n",
-    "chain1 = prompt | model\n",
-    "\n",
-    "chain = (\n",
-    "    {\n",
-    "        \"a\": itemgetter(\"foo\") | RunnableLambda(length_function),\n",
-    "        \"b\": {\"text1\": itemgetter(\"foo\"), \"text2\": itemgetter(\"bar\")}\n",
-    "        | RunnableLambda(multiple_length_function),\n",
-    "    }\n",
-    "    | prompt\n",
-    "    | model\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "5488ec85",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "AIMessage(content='3 + 9 equals 12.')"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "chain.invoke({\"foo\": \"bar\", \"bar\": \"gah\"})"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "4728ddd9-914d-42ce-ae9b-72c9ce8ec940",
-   "metadata": {},
-   "source": [
-    "## Accepting a Runnable Config\n",
-    "\n",
-    "Runnable lambdas can optionally accept a [RunnableConfig](https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.config.RunnableConfig.html#langchain_core.runnables.config.RunnableConfig), which they can use to pass callbacks, tags, and other configuration information to nested runs."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "80b3b5f6-5d58-44b9-807e-cce9a46bf49f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain_core.output_parsers import StrOutputParser\n",
-    "from langchain_core.runnables import RunnableConfig"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "ff0daf0c-49dd-4d21-9772-e5fa133c5f36",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import json\n",
-    "\n",
-    "\n",
-    "def parse_or_fix(text: str, config: RunnableConfig):\n",
-    "    fixing_chain = (\n",
-    "        ChatPromptTemplate.from_template(\n",
-    "            \"Fix the following text:\\n\\n```text\\n{input}\\n```\\nError: {error}\"\n",
-    "            \" Don't narrate, just respond with the fixed data.\"\n",
-    "        )\n",
-    "        | ChatOpenAI()\n",
-    "        | StrOutputParser()\n",
-    "    )\n",
-    "    for _ in range(3):\n",
-    "        try:\n",
-    "            return json.loads(text)\n",
-    "        except Exception as e:\n",
-    "            text = fixing_chain.invoke({\"input\": text, \"error\": e}, config)\n",
-    "    return \"Failed to parse\""
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "1a5e709e-9d75-48c7-bb9c-503251990505",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'foo': 'bar'}\n",
-      "Tokens Used: 65\n",
-      "\tPrompt Tokens: 56\n",
-      "\tCompletion Tokens: 9\n",
-      "Successful Requests: 1\n",
-      "Total Cost (USD): $0.00010200000000000001\n"
-     ]
-    }
-   ],
-   "source": [
-    "from langchain.callbacks import get_openai_callback\n",
-    "\n",
-    "with get_openai_callback() as cb:\n",
-    "    output = RunnableLambda(parse_or_fix).invoke(\n",
-    "        \"{foo: bar}\", {\"tags\": [\"my-tag\"], \"callbacks\": [cb]}\n",
-    "    )\n",
-    "    print(output)\n",
-    "    print(cb)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "29f55c38",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "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.1"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/expression_language/how_to/index.mdx

@@ -1,9 +0,0 @@
----
-sidebar_position: 2
----
-
-# How to
-
-import DocCardList from "@theme/DocCardList";
-
-<DocCardList />

docs/docs/expression_language/how_to/inspect.ipynb

@@ -30,9 +30,9 @@
    "outputs": [],
    "source": [
     "from langchain.prompts import ChatPromptTemplate\n",
-    "from langchain.vectorstores import FAISS\n",
+    "from langchain_community.vectorstores import FAISS\n",
     "from langchain_core.output_parsers import StrOutputParser\n",
-    "from langchain_core.runnables import RunnableLambda, RunnablePassthrough\n",
+    "from langchain_core.runnables import RunnablePassthrough\n",
     "from langchain_openai import ChatOpenAI, OpenAIEmbeddings"
    ]
   },

docs/docs/expression_language/how_to/message_history.ipynb

@@ -552,7 +552,7 @@
    "id": "da3d1feb-b4bb-4624-961c-7db2e1180df7",
    "metadata": {},
    "source": [
-    ":::tip\n",
+    ":::{.callout-tip}\n",
     "\n",
     "[Langsmith trace](https://smith.langchain.com/public/bd73e122-6ec1-48b2-82df-e6483dc9cb63/r)\n",
     "\n",

docs/docs/expression_language/how_to/routing.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "---\n",
     "sidebar_position: 3\n",
-    "title: \"RunnableBranch: Dynamically route logic based on input\"\n",
+    "title: \"Route logic based on input\"\n",
     "keywords: [RunnableBranch, LCEL]\n",
     "---"
    ]
@@ -25,7 +25,7 @@
     "\n",
     "There are two ways to perform routing:\n",
     "\n",
-    "1. Conditionally return runnables from a [`RunnableLambda`](./functions) (recommended)\n",
+    "1. Conditionally return runnables from a [`RunnableLambda`](/docs/expression_language/primitives/functions) (recommended)\n",
     "2. Using a `RunnableBranch`.\n",
     "\n",
     "We'll illustrate both methods using a two step sequence where the first step classifies an input question as being about `LangChain`, `Anthropic`, or `Other`, then routes to a corresponding prompt chain."
@@ -42,22 +42,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "id": "8a8a1967",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "' Anthropic'"
+       "'Anthropic'"
       ]
      },
+     "execution_count": 1,
      "metadata": {},
-     "output_type": "display_data"
+     "output_type": "execute_result"
     }
    ],
    "source": [
-    "from langchain_community.chat_models import ChatAnthropic\n",
+    "from langchain_anthropic import ChatAnthropic\n",
     "from langchain_core.output_parsers import StrOutputParser\n",
     "from langchain_core.prompts import PromptTemplate\n",
     "\n",
@@ -73,7 +74,7 @@
     "\n",
     "Classification:\"\"\"\n",
     "    )\n",
-    "    | ChatAnthropic()\n",
+    "    | ChatAnthropic(model_name=\"claude-3-haiku-20240307\")\n",
     "    | StrOutputParser()\n",
     ")\n",
     "\n",
@@ -90,42 +91,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "id": "89d7722d",
    "metadata": {},
    "outputs": [],
    "source": [
-    "langchain_chain = (\n",
-    "    PromptTemplate.from_template(\n",
-    "        \"\"\"You are an expert in langchain. \\\n",
+    "langchain_chain = PromptTemplate.from_template(\n",
+    "    \"\"\"You are an expert in langchain. \\\n",
     "Always answer questions starting with \"As Harrison Chase told me\". \\\n",
     "Respond to the following question:\n",
     "\n",
     "Question: {question}\n",
     "Answer:\"\"\"\n",
-    "    )\n",
-    "    | ChatAnthropic()\n",
-    ")\n",
-    "anthropic_chain = (\n",
-    "    PromptTemplate.from_template(\n",
-    "        \"\"\"You are an expert in anthropic. \\\n",
+    ") | ChatAnthropic(model_name=\"claude-3-haiku-20240307\")\n",
+    "anthropic_chain = PromptTemplate.from_template(\n",
+    "    \"\"\"You are an expert in anthropic. \\\n",
     "Always answer questions starting with \"As Dario Amodei told me\". \\\n",
     "Respond to the following question:\n",
     "\n",
     "Question: {question}\n",
     "Answer:\"\"\"\n",
-    "    )\n",
-    "    | ChatAnthropic()\n",
-    ")\n",
-    "general_chain = (\n",
-    "    PromptTemplate.from_template(\n",
-    "        \"\"\"Respond to the following question:\n",
+    ") | ChatAnthropic(model_name=\"claude-3-haiku-20240307\")\n",
+    "general_chain = PromptTemplate.from_template(\n",
+    "    \"\"\"Respond to the following question:\n",
     "\n",
     "Question: {question}\n",
     "Answer:\"\"\"\n",
-    "    )\n",
-    "    | ChatAnthropic()\n",
-    ")"
+    ") | ChatAnthropic(model_name=\"claude-3-haiku-20240307\")"
    ]
   },
   {
@@ -140,7 +132,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 4,
    "id": "687492da",
    "metadata": {},
    "outputs": [],
@@ -156,7 +148,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 5,
    "id": "02a33c86",
    "metadata": {},
    "outputs": [],
@@ -170,17 +162,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 6,
    "id": "c2e977a4",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "AIMessage(content=' As Dario Amodei told me, to use Anthropic IPC you first need to import it:\\n\\n```python\\nfrom anthroipc import ic\\n```\\n\\nThen you can create a client and connect to the server:\\n\\n```python \\nclient = ic.connect()\\n```\\n\\nAfter that, you can call methods on the client and get responses:\\n\\n```python\\nresponse = client.ask(\"What is the meaning of life?\")\\nprint(response)\\n```\\n\\nYou can also register callbacks to handle events: \\n\\n```python\\ndef on_poke(event):\\n  print(\"Got poked!\")\\n\\nclient.on(\\'poke\\', on_poke)\\n```\\n\\nAnd that\\'s the basics of using the Anthropic IPC client library for Python! Let me know if you have any other questions!', additional_kwargs={}, example=False)"
+       "AIMessage(content=\"As Dario Amodei told me, to use Anthropic, you can start by exploring the company's website and learning about their mission, values, and the different services and products they offer. Anthropic is focused on developing safe and ethical AI systems, so they have a strong emphasis on transparency and responsible AI development. \\n\\nDepending on your specific needs, you can look into Anthropic's AI research and development services, which cover areas like natural language processing, computer vision, and reinforcement learning. They also offer consulting and advisory services to help organizations navigate the challenges and opportunities of AI integration.\\n\\nAdditionally, Anthropic has released some open-source AI models and tools that you can explore and experiment with. These can be a great way to get hands-on experience with Anthropic's approach to AI development.\\n\\nOverall, Anthropic aims to be a reliable and trustworthy partner in the AI space, so I'd encourage you to reach out to them directly to discuss how they can best support your specific requirements.\", response_metadata={'id': 'msg_01CtLFgFSwvTaJomrihE87Ra', 'content': [ContentBlock(text=\"As Dario Amodei told me, to use Anthropic, you can start by exploring the company's website and learning about their mission, values, and the different services and products they offer. Anthropic is focused on developing safe and ethical AI systems, so they have a strong emphasis on transparency and responsible AI development. \\n\\nDepending on your specific needs, you can look into Anthropic's AI research and development services, which cover areas like natural language processing, computer vision, and reinforcement learning. They also offer consulting and advisory services to help organizations navigate the challenges and opportunities of AI integration.\\n\\nAdditionally, Anthropic has released some open-source AI models and tools that you can explore and experiment with. These can be a great way to get hands-on experience with Anthropic's approach to AI development.\\n\\nOverall, Anthropic aims to be a reliable and trustworthy partner in the AI space, so I'd encourage you to reach out to them directly to discuss how they can best support your specific requirements.\", type='text')], 'model': 'claude-3-haiku-20240307', 'role': 'assistant', 'stop_reason': 'end_turn', 'stop_sequence': None, 'type': 'message', 'usage': Usage(input_tokens=53, output_tokens=219)})"
       ]
      },
-     "execution_count": 12,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -191,17 +183,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 7,
    "id": "48913dc6",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "AIMessage(content=' As Harrison Chase told me, to use LangChain you first need to sign up for an API key at platform.langchain.com. Once you have your API key, you can install the Python library and write a simple Python script to call the LangChain API. Here is some sample code to get started:\\n\\n```python\\nimport langchain\\n\\napi_key = \"YOUR_API_KEY\"\\n\\nlangchain.set_key(api_key)\\n\\nresponse = langchain.ask(\"What is the capital of France?\")\\n\\nprint(response.response)\\n```\\n\\nThis will send the question \"What is the capital of France?\" to the LangChain API and print the response. You can customize the request by providing parameters like max_tokens, temperature, etc. The LangChain Python library documentation has more details on the available options. The key things are getting an API key and calling langchain.ask() with your question text. Let me know if you have any other questions!', additional_kwargs={}, example=False)"
+       "AIMessage(content=\"As Harrison Chase told me, using LangChain involves a few key steps:\\n\\n1. **Set up your environment**: Install the necessary Python packages, including the LangChain library itself, as well as any other dependencies your application might require, such as language models or other integrations.\\n\\n2. **Understand the core concepts**: LangChain revolves around a few core concepts, like Agents, Chains, and Tools. Familiarize yourself with these concepts and how they work together to build powerful language-based applications.\\n\\n3. **Identify your use case**: Determine what kind of task or application you want to build using LangChain, such as a chatbot, a question-answering system, or a document summarization tool.\\n\\n4. **Choose the appropriate components**: Based on your use case, select the right LangChain components, such as agents, chains, and tools, to build your application.\\n\\n5. **Integrate with language models**: LangChain is designed to work seamlessly with various language models, such as OpenAI's GPT-3 or Anthropic's models. Connect your chosen language model to your LangChain application.\\n\\n6. **Implement your application logic**: Use LangChain's building blocks to implement the specific functionality of your application, such as prompting the language model, processing the response, and integrating with other services or data sources.\\n\\n7. **Test and iterate**: Thoroughly test your application, gather feedback, and iterate on your design and implementation to improve its performance and user experience.\\n\\nAs Harrison Chase emphasized, LangChain provides a flexible and powerful framework for building language-based applications, making it easier to leverage the capabilities of modern language models. By following these steps, you can get started with LangChain and create innovative solutions tailored to your specific needs.\", response_metadata={'id': 'msg_01H3UXAAHG4TwxJLpxwuuVU7', 'content': [ContentBlock(text=\"As Harrison Chase told me, using LangChain involves a few key steps:\\n\\n1. **Set up your environment**: Install the necessary Python packages, including the LangChain library itself, as well as any other dependencies your application might require, such as language models or other integrations.\\n\\n2. **Understand the core concepts**: LangChain revolves around a few core concepts, like Agents, Chains, and Tools. Familiarize yourself with these concepts and how they work together to build powerful language-based applications.\\n\\n3. **Identify your use case**: Determine what kind of task or application you want to build using LangChain, such as a chatbot, a question-answering system, or a document summarization tool.\\n\\n4. **Choose the appropriate components**: Based on your use case, select the right LangChain components, such as agents, chains, and tools, to build your application.\\n\\n5. **Integrate with language models**: LangChain is designed to work seamlessly with various language models, such as OpenAI's GPT-3 or Anthropic's models. Connect your chosen language model to your LangChain application.\\n\\n6. **Implement your application logic**: Use LangChain's building blocks to implement the specific functionality of your application, such as prompting the language model, processing the response, and integrating with other services or data sources.\\n\\n7. **Test and iterate**: Thoroughly test your application, gather feedback, and iterate on your design and implementation to improve its performance and user experience.\\n\\nAs Harrison Chase emphasized, LangChain provides a flexible and powerful framework for building language-based applications, making it easier to leverage the capabilities of modern language models. By following these steps, you can get started with LangChain and create innovative solutions tailored to your specific needs.\", type='text')], 'model': 'claude-3-haiku-20240307', 'role': 'assistant', 'stop_reason': 'end_turn', 'stop_sequence': None, 'type': 'message', 'usage': Usage(input_tokens=50, output_tokens=400)})"
       ]
      },
-     "execution_count": 13,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -212,17 +204,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 8,
    "id": "a14d0dca",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "AIMessage(content=' 4', additional_kwargs={}, example=False)"
+       "AIMessage(content='4', response_metadata={'id': 'msg_01UAKP81jTZu9fyiyFYhsbHc', 'content': [ContentBlock(text='4', type='text')], 'model': 'claude-3-haiku-20240307', 'role': 'assistant', 'stop_reason': 'end_turn', 'stop_sequence': None, 'type': 'message', 'usage': Usage(input_tokens=28, output_tokens=5)})"
       ]
      },
-     "execution_count": 14,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -249,18 +241,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 9,
    "id": "2a101418",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "AIMessage(content=\" As Dario Amodei told me, here are some ways to use Anthropic:\\n\\n- Sign up for an account on Anthropic's website to access tools like Claude, Constitutional AI, and Writer. \\n\\n- Use Claude for tasks like email generation, customer service chat, and QA. Claude can understand natural language prompts and provide helpful responses.\\n\\n- Use Constitutional AI if you need an AI assistant that is harmless, honest, and helpful. It is designed to be safe and aligned with human values.\\n\\n- Use Writer to generate natural language content for things like marketing copy, stories, reports, and more. Give it a topic and prompt and it will create high-quality written content.\\n\\n- Check out Anthropic's documentation and blog for tips, tutorials, examples, and announcements about new capabilities as they continue to develop their AI technology.\\n\\n- Follow Anthropic on social media or subscribe to their newsletter to stay up to date on new features and releases.\\n\\n- For most people, the easiest way to leverage Anthropic's technology is through their website - just create an account to get started!\", additional_kwargs={}, example=False)"
+       "AIMessage(content=\"As Dario Amodei told me, to use Anthropic, you should first familiarize yourself with our mission and principles. Anthropic is committed to developing safe and beneficial artificial intelligence that can help solve important problems facing humanity. \\n\\nTo get started, I recommend exploring the resources on our website, which cover our research, products, and approach to AI development. You can also reach out to our team to learn more about how Anthropic's technology and services can support your specific needs.\\n\\nThe key is to engage with us in a way that aligns with our values of transparency, ethical AI, and a commitment to the wellbeing of humanity. We're here to collaborate and help you harness the power of advanced AI responsibly.\", response_metadata={'id': 'msg_0187BVnpniPDJnVvwf3M1LdY', 'content': [ContentBlock(text=\"As Dario Amodei told me, to use Anthropic, you should first familiarize yourself with our mission and principles. Anthropic is committed to developing safe and beneficial artificial intelligence that can help solve important problems facing humanity. \\n\\nTo get started, I recommend exploring the resources on our website, which cover our research, products, and approach to AI development. You can also reach out to our team to learn more about how Anthropic's technology and services can support your specific needs.\\n\\nThe key is to engage with us in a way that aligns with our values of transparency, ethical AI, and a commitment to the wellbeing of humanity. We're here to collaborate and help you harness the power of advanced AI responsibly.\", type='text')], 'model': 'claude-3-haiku-20240307', 'role': 'assistant', 'stop_reason': 'end_turn', 'stop_sequence': None, 'type': 'message', 'usage': Usage(input_tokens=53, output_tokens=160)})"
       ]
      },
+     "execution_count": 9,
      "metadata": {},
-     "output_type": "display_data"
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -277,18 +270,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "id": "8d8caf9b",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "AIMessage(content=' As Harrison Chase told me, here is how you use LangChain:\\n\\nLangChain is an AI assistant that can have conversations, answer questions, and generate text. To use LangChain, you simply type or speak your input and LangChain will respond. \\n\\nYou can ask LangChain questions, have discussions, get summaries or explanations about topics, and request it to generate text on a subject. Some examples of interactions:\\n\\n- Ask general knowledge questions and LangChain will try to answer factually. For example \"What is the capital of France?\"\\n\\n- Have conversations on topics by taking turns speaking. You can prompt the start of a conversation by saying something like \"Let\\'s discuss machine learning\"\\n\\n- Ask for summaries or high-level explanations on subjects. For example \"Can you summarize the main themes in Shakespeare\\'s Hamlet?\" \\n\\n- Give creative writing prompts or requests to have LangChain generate text in different styles. For example \"Write a short children\\'s story about a mouse\" or \"Generate a poem in the style of Robert Frost about nature\"\\n\\n- Correct LangChain if it makes an inaccurate statement and provide the right information. This helps train it.\\n\\nThe key is interacting naturally and giving it clear prompts and requests', additional_kwargs={}, example=False)"
+       "AIMessage(content=\"As Harrison Chase told me, using LangChain involves several key steps. First, you'll need to install the LangChain library and import the necessary modules. Then, you'll want to define your language model, any data sources you plan to use, and the specific tasks you want to accomplish, such as question answering, text generation, or agent-based reasoning. \\n\\nLangChain provides a flexible framework for building applications that leverage large language models. It includes abstractions for things like retrievers, prompts, and chains, which allow you to compose different components together to create powerful workflows. \\n\\nThe documentation on the LangChain website is excellent and covers many common use cases in detail. I'd recommend starting there to get a solid understanding of the core concepts and how to apply them to your specific needs. And of course, feel free to reach out if you have any other questions - I'm always happy to share more insights from my conversations with Harrison.\", response_metadata={'id': 'msg_01T1naS99wGPkEAP4LME8iAv', 'content': [ContentBlock(text=\"As Harrison Chase told me, using LangChain involves several key steps. First, you'll need to install the LangChain library and import the necessary modules. Then, you'll want to define your language model, any data sources you plan to use, and the specific tasks you want to accomplish, such as question answering, text generation, or agent-based reasoning. \\n\\nLangChain provides a flexible framework for building applications that leverage large language models. It includes abstractions for things like retrievers, prompts, and chains, which allow you to compose different components together to create powerful workflows. \\n\\nThe documentation on the LangChain website is excellent and covers many common use cases in detail. I'd recommend starting there to get a solid understanding of the core concepts and how to apply them to your specific needs. And of course, feel free to reach out if you have any other questions - I'm always happy to share more insights from my conversations with Harrison.\", type='text')], 'model': 'claude-3-haiku-20240307', 'role': 'assistant', 'stop_reason': 'end_turn', 'stop_sequence': None, 'type': 'message', 'usage': Usage(input_tokens=50, output_tokens=205)})"
       ]
      },
+     "execution_count": 10,
      "metadata": {},
-     "output_type": "display_data"
+     "output_type": "execute_result"
     }
    ],
    "source": [
@@ -297,23 +291,150 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
    "id": "26159af7",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "AIMessage(content=' 2 + 2 = 4', additional_kwargs={}, example=False)"
+       "AIMessage(content='4', response_metadata={'id': 'msg_01T6T3TS6hRCtU8JayN93QEi', 'content': [ContentBlock(text='4', type='text')], 'model': 'claude-3-haiku-20240307', 'role': 'assistant', 'stop_reason': 'end_turn', 'stop_sequence': None, 'type': 'message', 'usage': Usage(input_tokens=28, output_tokens=5)})"
       ]
      },
+     "execution_count": 11,
      "metadata": {},
-     "output_type": "display_data"
+     "output_type": "execute_result"
     }
    ],
    "source": [
     "full_chain.invoke({\"question\": \"whats 2 + 2\"})"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fa0f589d",
+   "metadata": {},
+   "source": [
+    "# Routing by semantic similarity\n",
+    "\n",
+    "One especially useful technique is to use embeddings to route a query to the most relevant prompt. Here's an example."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "a23457d7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.utils.math import cosine_similarity\n",
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.prompts import PromptTemplate\n",
+    "from langchain_core.runnables import RunnableLambda, RunnablePassthrough\n",
+    "from langchain_openai import OpenAIEmbeddings\n",
+    "\n",
+    "physics_template = \"\"\"You are a very smart physics professor. \\\n",
+    "You are great at answering questions about physics in a concise and easy to understand manner. \\\n",
+    "When you don't know the answer to a question you admit that you don't know.\n",
+    "\n",
+    "Here is a question:\n",
+    "{query}\"\"\"\n",
+    "\n",
+    "math_template = \"\"\"You are a very good mathematician. You are great at answering math questions. \\\n",
+    "You are so good because you are able to break down hard problems into their component parts, \\\n",
+    "answer the component parts, and then put them together to answer the broader question.\n",
+    "\n",
+    "Here is a question:\n",
+    "{query}\"\"\"\n",
+    "\n",
+    "embeddings = OpenAIEmbeddings()\n",
+    "prompt_templates = [physics_template, math_template]\n",
+    "prompt_embeddings = embeddings.embed_documents(prompt_templates)\n",
+    "\n",
+    "\n",
+    "def prompt_router(input):\n",
+    "    query_embedding = embeddings.embed_query(input[\"query\"])\n",
+    "    similarity = cosine_similarity([query_embedding], prompt_embeddings)[0]\n",
+    "    most_similar = prompt_templates[similarity.argmax()]\n",
+    "    print(\"Using MATH\" if most_similar == math_template else \"Using PHYSICS\")\n",
+    "    return PromptTemplate.from_template(most_similar)\n",
+    "\n",
+    "\n",
+    "chain = (\n",
+    "    {\"query\": RunnablePassthrough()}\n",
+    "    | RunnableLambda(prompt_router)\n",
+    "    | ChatAnthropic(model_name=\"claude-3-haiku-20240307\")\n",
+    "    | StrOutputParser()\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "664bb851",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Using PHYSICS\n",
+      "As a physics professor, I would be happy to provide a concise and easy-to-understand explanation of what a black hole is.\n",
+      "\n",
+      "A black hole is an incredibly dense region of space-time where the gravitational pull is so strong that nothing, not even light, can escape from it. This means that if you were to get too close to a black hole, you would be pulled in and crushed by the intense gravitational forces.\n",
+      "\n",
+      "The formation of a black hole occurs when a massive star, much larger than our Sun, reaches the end of its life and collapses in on itself. This collapse causes the matter to become extremely dense, and the gravitational force becomes so strong that it creates a point of no return, known as the event horizon.\n",
+      "\n",
+      "Beyond the event horizon, the laws of physics as we know them break down, and the intense gravitational forces create a singularity, which is a point of infinite density and curvature in space-time.\n",
+      "\n",
+      "Black holes are fascinating and mysterious objects, and there is still much to be learned about their properties and behavior. If I were unsure about any specific details or aspects of black holes, I would readily admit that I do not have a complete understanding and would encourage further research and investigation.\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(chain.invoke(\"What's a black hole\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "df34e469",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Using MATH\n",
+      "A path integral is a powerful mathematical concept in physics, particularly in the field of quantum mechanics. It was developed by the renowned physicist Richard Feynman as an alternative formulation of quantum mechanics.\n",
+      "\n",
+      "In a path integral, instead of considering a single, definite path that a particle might take from one point to another, as in classical mechanics, the particle is considered to take all possible paths simultaneously. Each path is assigned a complex-valued weight, and the total probability amplitude for the particle to go from one point to another is calculated by summing (integrating) over all possible paths.\n",
+      "\n",
+      "The key ideas behind the path integral formulation are:\n",
+      "\n",
+      "1. Superposition principle: In quantum mechanics, particles can exist in a superposition of multiple states or paths simultaneously.\n",
+      "\n",
+      "2. Probability amplitude: The probability amplitude for a particle to go from one point to another is calculated by summing the complex-valued weights of all possible paths.\n",
+      "\n",
+      "3. Weighting of paths: Each path is assigned a weight based on the action (the time integral of the Lagrangian) along that path. Paths with lower action have a greater weight.\n",
+      "\n",
+      "4. Feynman's approach: Feynman developed the path integral formulation as an alternative to the traditional wave function approach in quantum mechanics, providing a more intuitive and conceptual understanding of quantum phenomena.\n",
+      "\n",
+      "The path integral approach is particularly useful in quantum field theory, where it provides a powerful framework for calculating transition probabilities and understanding the behavior of quantum systems. It has also found applications in various areas of physics, such as condensed matter, statistical mechanics, and even in finance (the path integral approach to option pricing).\n",
+      "\n",
+      "The mathematical construction of the path integral involves the use of advanced concepts from functional analysis and measure theory, making it a powerful and sophisticated tool in the physicist's arsenal.\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(chain.invoke(\"What's a path integral\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "927b7498",
+   "metadata": {},
+   "source": []
   }
  ],
  "metadata": {
@@ -332,7 +453,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.1"
+   "version": "3.10.5"
   }
  },
  "nbformat": 4,

docs/docs/expression_language/index.mdx

@@ -7,27 +7,27 @@ sidebar_class_name: hidden
 LangChain Expression Language, or LCEL, is a declarative way to easily compose chains together.
 LCEL was designed from day 1 to **support putting prototypes in production, with no code changes**, from the simplest “prompt + LLM” chain to the most complex chains (we’ve seen folks successfully run LCEL chains with 100s of steps in production). To highlight a few of the reasons you might want to use LCEL:
 
-**Streaming support**
+[**First-class streaming support**](/docs/expression_language/streaming)
 When you build your chains with LCEL you get the best possible time-to-first-token (time elapsed until the first chunk of output comes out). For some chains this means eg. we stream tokens straight from an LLM to a streaming output parser, and you get back parsed, incremental chunks of output at the same rate as the LLM provider outputs the raw tokens.
 
-**Async support**
+[**Async support**](/docs/expression_language/interface)
 Any chain built with LCEL can be called both with the synchronous API (eg. in your Jupyter notebook while prototyping) as well as with the asynchronous API (eg. in a [LangServe](/docs/langsmith) server). This enables using the same code for prototypes and in production, with great performance, and the ability to handle many concurrent requests in the same server.
 
-**Optimized parallel execution**
+[**Optimized parallel execution**](/docs/expression_language/primitives/parallel)
 Whenever your LCEL chains have steps that can be executed in parallel (eg if you fetch documents from multiple retrievers) we automatically do it, both in the sync and the async interfaces, for the smallest possible latency.
 
-**Retries and fallbacks**
+[**Retries and fallbacks**](/docs/guides/productionization/fallbacks)
 Configure retries and fallbacks for any part of your LCEL chain. This is a great way to make your chains more reliable at scale. We’re currently working on adding streaming support for retries/fallbacks, so you can get the added reliability without any latency cost.
 
-**Access intermediate results**
+[**Access intermediate results**](/docs/expression_language/interface#async-stream-events-beta)
 For more complex chains it’s often very useful to access the results of intermediate steps even before the final output is produced. This can be used to let end-users know something is happening, or even just to debug your chain. You can stream intermediate results, and it’s available on every [LangServe](/docs/langserve) server.
 
-**Input and output schemas**
+[**Input and output schemas**](/docs/expression_language/interface#input-schema)
 Input and output schemas give every LCEL chain Pydantic and JSONSchema schemas inferred from the structure of your chain. This can be used for validation of inputs and outputs, and is an integral part of LangServe.
 
-**Seamless LangSmith tracing integration**
+[**Seamless LangSmith tracing**](/docs/langsmith)
 As your chains get more and more complex, it becomes increasingly important to understand what exactly is happening at every step.
 With LCEL, **all** steps are automatically logged to [LangSmith](/docs/langsmith/) for maximum observability and debuggability.
 
-**Seamless LangServe deployment integration**
+[**Seamless LangServe deployment**](/docs/langserve)
 Any chain created with LCEL can be easily deployed using [LangServe](/docs/langserve).

docs/docs/expression_language/interface.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "---\n",
     "sidebar_position: 1\n",
-    "title: Interface\n",
+    "title: Runnable interface\n",
     "---"
    ]
   },
@@ -16,7 +16,8 @@
    "id": "9a9acd2e",
    "metadata": {},
    "source": [
-    "To make it as easy as possible to create custom chains, we've implemented a [\"Runnable\"](https://api.python.langchain.com/en/stable/runnables/langchain_core.runnables.base.Runnable.html#langchain_core.runnables.base.Runnable) protocol. The `Runnable` protocol is implemented for most components. \n",
+    "To make it as easy as possible to create custom chains, we've implemented a [\"Runnable\"](https://api.python.langchain.com/en/stable/runnables/langchain_core.runnables.base.Runnable.html#langchain_core.runnables.base.Runnable) protocol. Many LangChain components implement the `Runnable` protocol, including chat models, LLMs, output parsers, retrievers, prompt templates, and more. There are also several useful primitives for working with runnables, which you can read about [in this section](/docs/expression_language/primitives).\n",
+    "\n",
     "This is a standard interface, which makes it easy to define custom chains as well as invoke them in a standard way. \n",
     "The standard interface includes:\n",
     "\n",
@@ -24,7 +25,7 @@
     "- [`invoke`](#invoke): call the chain on an input\n",
     "- [`batch`](#batch): call the chain on a list of inputs\n",
     "\n",
-    "These also have corresponding async methods:\n",
+    "These also have corresponding async methods that should be used with [asyncio](https://docs.python.org/3/library/asyncio.html) `await` syntax for concurrency:\n",
     "\n",
     "- [`astream`](#async-stream): stream back chunks of the response async\n",
     "- [`ainvoke`](#async-invoke): call the chain on an input async\n",
@@ -52,9 +53,11 @@
    ]
   },
   {
-   "cell_type": "raw",
+   "cell_type": "code",
+   "execution_count": null,
    "id": "57768739",
    "metadata": {},
+   "outputs": [],
    "source": [
     "%pip install --upgrade --quiet  langchain-core langchain-community langchain-openai"
    ]

docs/docs/expression_language/primitives/assign.ipynb

@@ -0,0 +1,180 @@
+{
+ "cells": [
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "sidebar_position: 6\n",
+    "title: \"Assign: Add values to state\"\n",
+    "keywords: [RunnablePassthrough, assign, LCEL]\n",
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Adding values to chain state\n",
+    "\n",
+    "The `RunnablePassthrough.assign(...)` static method takes an input value and adds the extra arguments passed to the assign function.\n",
+    "\n",
+    "This is useful when additively creating a dictionary to use as input to a later step, which is a common LCEL pattern.\n",
+    "\n",
+    "Here's an example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[33mWARNING: You are using pip version 22.0.4; however, version 24.0 is available.\n",
+      "You should consider upgrading via the '/Users/jacoblee/.pyenv/versions/3.10.5/bin/python -m pip install --upgrade pip' command.\u001b[0m\u001b[33m\n",
+      "\u001b[0mNote: you may need to restart the kernel to use updated packages.\n"
+     ]
+    }
+   ],
+   "source": [
+    "%pip install --upgrade --quiet langchain langchain-openai"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'extra': {'num': 1, 'mult': 3}, 'modified': 2}"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain_core.runnables import RunnableParallel, RunnablePassthrough\n",
+    "\n",
+    "runnable = RunnableParallel(\n",
+    "    extra=RunnablePassthrough.assign(mult=lambda x: x[\"num\"] * 3),\n",
+    "    modified=lambda x: x[\"num\"] + 1,\n",
+    ")\n",
+    "\n",
+    "runnable.invoke({\"num\": 1})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's break down what's happening here.\n",
+    "\n",
+    "- The input to the chain is `{\"num\": 1}`. This is passed into a `RunnableParallel`, which invokes the runnables it is passed in parallel with that input.\n",
+    "- The value under the `extra` key is invoked. `RunnablePassthrough.assign()` keeps the original keys in the input dict (`{\"num\": 1}`), and assigns a new key called `mult`. The value is `lambda x: x[\"num\"] * 3)`, which is `3`. Thus, the result is `{\"num\": 1, \"mult\": 3}`.\n",
+    "- `{\"num\": 1, \"mult\": 3}` is returned to the `RunnableParallel` call, and is set as the value to the key `extra`.\n",
+    "- At the same time, the `modified` key is called. The result is `2`, since the lambda extracts a key called `\"num\"` from its input and adds one.\n",
+    "\n",
+    "Thus, the result is `{'extra': {'num': 1, 'mult': 3}, 'modified': 2}`.\n",
+    "\n",
+    "## Streaming\n",
+    "\n",
+    "One nice feature of this method is that it allows values to pass through as soon as they are available. To show this off, we'll use `RunnablePassthrough.assign()` to immediately return source docs in a retrieval chain:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'question': 'where did harrison work?'}\n",
+      "{'context': [Document(page_content='harrison worked at kensho')]}\n",
+      "{'output': ''}\n",
+      "{'output': 'H'}\n",
+      "{'output': 'arrison'}\n",
+      "{'output': ' worked'}\n",
+      "{'output': ' at'}\n",
+      "{'output': ' Kens'}\n",
+      "{'output': 'ho'}\n",
+      "{'output': '.'}\n",
+      "{'output': ''}\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain_community.vectorstores import FAISS\n",
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.prompts import ChatPromptTemplate\n",
+    "from langchain_core.runnables import RunnablePassthrough\n",
+    "from langchain_openai import ChatOpenAI, OpenAIEmbeddings\n",
+    "\n",
+    "vectorstore = FAISS.from_texts(\n",
+    "    [\"harrison worked at kensho\"], embedding=OpenAIEmbeddings()\n",
+    ")\n",
+    "retriever = vectorstore.as_retriever()\n",
+    "template = \"\"\"Answer the question based only on the following context:\n",
+    "{context}\n",
+    "\n",
+    "Question: {question}\n",
+    "\"\"\"\n",
+    "prompt = ChatPromptTemplate.from_template(template)\n",
+    "model = ChatOpenAI()\n",
+    "\n",
+    "generation_chain = prompt | model | StrOutputParser()\n",
+    "\n",
+    "retrieval_chain = {\n",
+    "    \"context\": retriever,\n",
+    "    \"question\": RunnablePassthrough(),\n",
+    "} | RunnablePassthrough.assign(output=generation_chain)\n",
+    "\n",
+    "stream = retrieval_chain.stream(\"where did harrison work?\")\n",
+    "\n",
+    "for chunk in stream:\n",
+    "    print(chunk)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can see that the first chunk contains the original `\"question\"` since that is immediately available. The second chunk contains `\"context\"` since the retriever finishes second. Finally, the output from the `generation_chain` streams in chunks as soon as it is available."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

docs/docs/expression_language/primitives/binding.ipynb

@@ -1,13 +1,25 @@
 {
  "cells": [
+  {
+   "cell_type": "raw",
+   "id": "fe63ffaf",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "sidebar_position: 2\n",
+    "title: \"Binding: Attach runtime args\"\n",
+    "keywords: [RunnableBinding, LCEL]\n",
+    "---"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "711752cb-4f15-42a3-9838-a0c67f397771",
    "metadata": {},
    "source": [
-    "# Bind runtime args\n",
+    "# Binding: Attach runtime args\n",
     "\n",
-    "Sometimes we want to invoke a Runnable within a Runnable sequence with constant arguments that are not part of the output of the preceding Runnable in the sequence, and which are not part of the user input. We can use `Runnable.bind()` to easily pass these arguments in.\n",
+    "Sometimes we want to invoke a Runnable within a Runnable sequence with constant arguments that are not part of the output of the preceding Runnable in the sequence, and which are not part of the user input. We can use `Runnable.bind()` to pass these arguments in.\n",
     "\n",
     "Suppose we have a simple prompt + model sequence:"
    ]

docs/docs/expression_language/primitives/configure.ipynb

@@ -1,5 +1,17 @@
 {
  "cells": [
+  {
+   "cell_type": "raw",
+   "id": "9ede5870",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "sidebar_position: 7\n",
+    "title: \"Configure runtime chain internals\"\n",
+    "keywords: [ConfigurableField, configurable_fields, ConfigurableAlternatives, configurable_alternatives, LCEL]\n",
+    "---"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "39eaf61b",

docs/docs/expression_language/primitives/functions.ipynb

@@ -1,10 +1,184 @@
 {
  "cells": [
   {
-   "cell_type": "markdown",
+   "cell_type": "raw",
+   "id": "ce0e08fd",
    "metadata": {},
    "source": [
-    "# Stream custom generator functions\n",
+    "---\n",
+    "sidebar_position: 3\n",
+    "title: \"Lambda: Run custom functions\"\n",
+    "keywords: [RunnableLambda, LCEL]\n",
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fbc4bf6e",
+   "metadata": {},
+   "source": [
+    "# Run custom functions\n",
+    "\n",
+    "You can use arbitrary functions in the pipeline.\n",
+    "\n",
+    "Note that all inputs to these functions need to be a SINGLE argument. If you have a function that accepts multiple arguments, you should write a wrapper that accepts a single input and unpacks it into multiple argument."
+   ]
+  },
+  {
+   "cell_type": "raw",
+   "id": "9a5fe916",
+   "metadata": {},
+   "source": [
+    "%pip install --upgrade --quiet langchain langchain-openai"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "6bb221b3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from operator import itemgetter\n",
+    "\n",
+    "from langchain_core.prompts import ChatPromptTemplate\n",
+    "from langchain_core.runnables import RunnableLambda\n",
+    "from langchain_openai import ChatOpenAI\n",
+    "\n",
+    "\n",
+    "def length_function(text):\n",
+    "    return len(text)\n",
+    "\n",
+    "\n",
+    "def _multiple_length_function(text1, text2):\n",
+    "    return len(text1) * len(text2)\n",
+    "\n",
+    "\n",
+    "def multiple_length_function(_dict):\n",
+    "    return _multiple_length_function(_dict[\"text1\"], _dict[\"text2\"])\n",
+    "\n",
+    "\n",
+    "prompt = ChatPromptTemplate.from_template(\"what is {a} + {b}\")\n",
+    "model = ChatOpenAI()\n",
+    "\n",
+    "chain1 = prompt | model\n",
+    "\n",
+    "chain = (\n",
+    "    {\n",
+    "        \"a\": itemgetter(\"foo\") | RunnableLambda(length_function),\n",
+    "        \"b\": {\"text1\": itemgetter(\"foo\"), \"text2\": itemgetter(\"bar\")}\n",
+    "        | RunnableLambda(multiple_length_function),\n",
+    "    }\n",
+    "    | prompt\n",
+    "    | model\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "5488ec85",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content='3 + 9 = 12', response_metadata={'token_usage': {'completion_tokens': 7, 'prompt_tokens': 14, 'total_tokens': 21}, 'model_name': 'gpt-3.5-turbo', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'stop', 'logprobs': None}, id='run-bd204541-81fd-429a-ad92-dd1913af9b1c-0')"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke({\"foo\": \"bar\", \"bar\": \"gah\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4728ddd9-914d-42ce-ae9b-72c9ce8ec940",
+   "metadata": {},
+   "source": [
+    "## Accepting a Runnable Config\n",
+    "\n",
+    "Runnable lambdas can optionally accept a [RunnableConfig](https://api.python.langchain.com/en/latest/runnables/langchain_core.runnables.config.RunnableConfig.html#langchain_core.runnables.config.RunnableConfig), which they can use to pass callbacks, tags, and other configuration information to nested runs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "80b3b5f6-5d58-44b9-807e-cce9a46bf49f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.runnables import RunnableConfig"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "ff0daf0c-49dd-4d21-9772-e5fa133c5f36",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "\n",
+    "\n",
+    "def parse_or_fix(text: str, config: RunnableConfig):\n",
+    "    fixing_chain = (\n",
+    "        ChatPromptTemplate.from_template(\n",
+    "            \"Fix the following text:\\n\\n```text\\n{input}\\n```\\nError: {error}\"\n",
+    "            \" Don't narrate, just respond with the fixed data.\"\n",
+    "        )\n",
+    "        | ChatOpenAI()\n",
+    "        | StrOutputParser()\n",
+    "    )\n",
+    "    for _ in range(3):\n",
+    "        try:\n",
+    "            return json.loads(text)\n",
+    "        except Exception as e:\n",
+    "            text = fixing_chain.invoke({\"input\": text, \"error\": e}, config)\n",
+    "    return \"Failed to parse\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "1a5e709e-9d75-48c7-bb9c-503251990505",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'foo': 'bar'}\n",
+      "Tokens Used: 62\n",
+      "\tPrompt Tokens: 56\n",
+      "\tCompletion Tokens: 6\n",
+      "Successful Requests: 1\n",
+      "Total Cost (USD): $9.6e-05\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain_community.callbacks import get_openai_callback\n",
+    "\n",
+    "with get_openai_callback() as cb:\n",
+    "    output = RunnableLambda(parse_or_fix).invoke(\n",
+    "        \"{foo: bar}\", {\"tags\": [\"my-tag\"], \"callbacks\": [cb]}\n",
+    "    )\n",
+    "    print(output)\n",
+    "    print(cb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "922b48bd",
+   "metadata": {},
+   "source": [
+    "# Streaming\n",
     "\n",
     "You can use generator functions (ie. functions that use the `yield` keyword, and behave like iterators) in a LCEL pipeline.\n",
     "\n",
@@ -14,39 +188,20 @@
     "- implementing a custom output parser\n",
     "- modifying the output of a previous step, while preserving streaming capabilities\n",
     "\n",
-    "Let's implement a custom output parser for comma-separated lists."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Sync version"
+    "Here's an example of a custom output parser for comma-separated lists:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%pip install --upgrade --quiet  langchain langchain-openai"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 6,
+   "id": "29f55c38",
    "metadata": {},
    "outputs": [],
    "source": [
     "from typing import Iterator, List\n",
     "\n",
-    "from langchain.prompts.chat import ChatPromptTemplate\n",
-    "from langchain_core.output_parsers import StrOutputParser\n",
-    "from langchain_openai import ChatOpenAI\n",
-    "\n",
     "prompt = ChatPromptTemplate.from_template(\n",
-    "    \"Write a comma-separated list of 5 animals similar to: {animal}\"\n",
+    "    \"Write a comma-separated list of 5 animals similar to: {animal}. Do not include numbers\"\n",
     ")\n",
     "model = ChatOpenAI(temperature=0.0)\n",
     "\n",
@@ -55,7 +210,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 7,
+   "id": "75aa946b",
    "metadata": {},
    "outputs": [
     {
@@ -73,7 +229,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 8,
+   "id": "d002a7fe",
    "metadata": {},
    "outputs": [
     {
@@ -82,7 +239,7 @@
        "'lion, tiger, wolf, gorilla, panda'"
       ]
      },
-     "execution_count": 3,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -93,7 +250,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 9,
+   "id": "f08b8a5b",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -119,7 +277,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 10,
+   "id": "02e414aa",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -128,7 +287,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 11,
+   "id": "7ed8799d",
    "metadata": {},
    "outputs": [
     {
@@ -150,16 +310,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 12,
+   "id": "9ea4ddc6",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "['lion', 'tiger', 'wolf', 'gorilla', 'panda']"
+       "['lion', 'tiger', 'wolf', 'gorilla', 'elephant']"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -170,6 +331,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "96e320ed",
    "metadata": {},
    "source": [
     "## Async version"
@@ -177,7 +339,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 13,
+   "id": "569dbbef",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -204,7 +367,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 14,
+   "id": "7a76b713",
    "metadata": {},
    "outputs": [
     {
@@ -226,7 +390,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 15,
+   "id": "3a650482",
    "metadata": {},
    "outputs": [
     {
@@ -235,7 +400,7 @@
        "['lion', 'tiger', 'wolf', 'gorilla', 'panda']"
       ]
      },
-     "execution_count": 10,
+     "execution_count": 15,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -261,9 +426,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.10.5"
   }
  },
  "nbformat": 4,
- "nbformat_minor": 4
+ "nbformat_minor": 5
 }

docs/docs/expression_language/primitives/index.mdx

@@ -0,0 +1,15 @@
+---
+sidebar_class_name: hidden
+---
+
+# Primitives
+
+In addition to various [components](/docs/modules) that are usable with LCEL, LangChain also includes various primitives
+that help pass around and format data, bind arguments, invoke custom logic, and more.
+
+This section goes into greater depth on where and how some of these components are useful.
+
+import DocCardList from "@theme/DocCardList";
+import { useCurrentSidebarCategory } from '@docusaurus/theme-common';
+
+<DocCardList items={useCurrentSidebarCategory().items.filter((item) => item.href !== "/docs/expression_language/primitives/")} />

docs/docs/expression_language/primitives/parallel.ipynb

@@ -6,8 +6,8 @@
    "metadata": {},
    "source": [
     "---\n",
-    "sidebar_position: 0\n",
-    "title: \"RunnableParallel: Manipulating data\"\n",
+    "sidebar_position: 1\n",
+    "title: \"Parallel: Format data\"\n",
     "keywords: [RunnableParallel, RunnableMap, LCEL]\n",
     "---"
    ]
@@ -17,13 +17,13 @@
    "id": "b022ab74-794d-4c54-ad47-ff9549ddb9d2",
    "metadata": {},
    "source": [
-    "# Manipulating inputs & output\n",
+    "# Formatting inputs & output\n",
     "\n",
-    "RunnableParallel can be useful for manipulating the output of one Runnable to match the input format of the next Runnable in a sequence.\n",
+    "The `RunnableParallel` primitive is essentially a dict whose values are runnables (or things that can be coerced to runnables, like functions). It runs all of its values in parallel, and each value is called with the overall input of the `RunnableParallel`. The final return value is a dict with the results of each value under its appropriate key.\n",
     "\n",
-    "Here the input to prompt is expected to be a map with keys \"context\" and \"question\". The user input is just the question. So we need to get the context using our retriever and passthrough the user input under the \"question\" key.\n",
+    "It is useful for parallelizing operations, but can also be useful for manipulating the output of one Runnable to match the input format of the next Runnable in a sequence.\n",
     "\n",
-    "\n"
+    "Here the input to prompt is expected to be a map with keys \"context\" and \"question\". The user input is just the question. So we need to get the context using our retriever and passthrough the user input under the \"question\" key.\n"
    ]
   },
   {

docs/docs/expression_language/primitives/passthrough.ipynb

@@ -1,14 +1,14 @@
 {
  "cells": [
   {
-   "cell_type": "markdown",
+   "cell_type": "raw",
    "id": "d35de667-0352-4bfb-a890-cebe7f676fe7",
    "metadata": {},
    "source": [
     "---\n",
-    "sidebar_position: 1\n",
-    "title: \"RunnablePassthrough: Passing data through\"\n",
-    "keywords: [RunnablePassthrough, RunnableParallel, LCEL]\n",
+    "sidebar_position: 5\n",
+    "title: \"Passthrough: Pass through inputs\"\n",
+    "keywords: [RunnablePassthrough, LCEL]\n",
     "---"
    ]
   },
@@ -19,11 +19,7 @@
    "source": [
     "# Passing data through\n",
     "\n",
-    "RunnablePassthrough allows to pass inputs unchanged or with the addition of extra keys. This typically is used in conjuction with RunnableParallel to assign data to a new key in the map. \n",
-    "\n",
-    "RunnablePassthrough() called on it's own, will simply take the input and pass it through. \n",
-    "\n",
-    "RunnablePassthrough called with assign (`RunnablePassthrough.assign(...)`) will take the input, and will add the extra arguments passed to the assign function. \n",
+    "RunnablePassthrough on its own allows you to pass inputs unchanged. This typically is used in conjuction with RunnableParallel to pass data through to a new key in the map. \n",
     "\n",
     "See the example below:"
    ]
@@ -60,7 +56,6 @@
     "\n",
     "runnable = RunnableParallel(\n",
     "    passed=RunnablePassthrough(),\n",
-    "    extra=RunnablePassthrough.assign(mult=lambda x: x[\"num\"] * 3),\n",
     "    modified=lambda x: x[\"num\"] + 1,\n",
     ")\n",
     "\n",
@@ -74,9 +69,7 @@
    "source": [
     "As seen above, `passed` key was called with `RunnablePassthrough()` and so it simply passed on `{'num': 1}`. \n",
     "\n",
-    "In the second line, we used `RunnablePastshrough.assign` with a lambda that multiplies the numerical value by 3. In this cased, `extra` was set with `{'num': 1, 'mult': 3}` which is the original value with the `mult` key added. \n",
-    "\n",
-    "Finally, we also set a third key in the map with `modified` which uses a lambda to set a single value adding 1 to the num, which resulted in `modified` key with the value of `2`."
+    "We also set a second key in the map with `modified`. This uses a lambda to set a single value adding 1 to the num, which resulted in `modified` key with the value of `2`."
    ]
   },
   {
@@ -86,7 +79,7 @@
    "source": [
     "## Retrieval Example\n",
     "\n",
-    "In the example below, we see a use case where we use RunnablePassthrough along with RunnableMap. "
+    "In the example below, we see a use case where we use `RunnablePassthrough` along with `RunnableParallel`. "
    ]
   },
   {

docs/docs/expression_language/primitives/sequence.ipynb

@@ -0,0 +1,243 @@
+{
+ "cells": [
+  {
+   "cell_type": "raw",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "sidebar_position: 0\n",
+    "title: \"Sequences: Chaining runnables\"\n",
+    "keywords: [Runnable, Runnables, LCEL]\n",
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Chaining runnables\n",
+    "\n",
+    "One key advantage of the `Runnable` interface is that any two runnables can be \"chained\" together into sequences. The output of the previous runnable's `.invoke()` call is passed as input to the next runnable. This can be done using the pipe operator (`|`), or the more explicit `.pipe()` method, which does the same thing. The resulting `RunnableSequence` is itself a runnable, which means it can be invoked, streamed, or piped just like any other runnable.\n",
+    "\n",
+    "## The pipe operator\n",
+    "\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/modules/model_io/prompts/) to format input into a [chat model](/docs/modules/model_io/chat/), and finally converting the chat message output into a string with an [output parser](/docs/modules/model_io/output_parsers/)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%pip install --upgrade --quiet langchain langchain-anthropic"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_anthropic import ChatAnthropic\n",
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "from langchain_core.prompts import ChatPromptTemplate\n",
+    "\n",
+    "prompt = ChatPromptTemplate.from_template(\"tell me a joke about {topic}\")\n",
+    "model = ChatAnthropic(model_name=\"claude-3-haiku-20240307\")\n",
+    "\n",
+    "chain = prompt | model | StrOutputParser()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Prompts and models are both runnable, and the output type from the prompt call is the same as the input type of the chat model, so we can chain them together. We can then invoke the resulting sequence like any other runnable:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"Here's a bear joke for you:\\n\\nWhy don't bears wear socks? \\nBecause they have bear feet!\\n\\nHow's that? I tried to keep it light and silly. Bears can make for some fun puns and jokes. Let me know if you'd like to hear another one!\""
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "chain.invoke({\"topic\": \"bears\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Coercion\n",
+    "\n",
+    "We can even combine this chain with more runnables to create another chain. This may involve some input/output formatting using other types of runnables, depending on the required inputs and outputs of the chain components.\n",
+    "\n",
+    "For example, let's say we wanted to compose the joke generating chain with another chain that evaluates whether or not the generated joke was funny.\n",
+    "\n",
+    "We would need to be careful with how we format the input into the next chain. In the below example, the dict in the chain is automatically parsed and converted into a [`RunnableParallel`](/docs/expression_language/primitives/parallel), which runs all of its values in parallel and returns a dict with the results.\n",
+    "\n",
+    "This happens to be the same format the next prompt template expects. Here it is in action:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.output_parsers import StrOutputParser\n",
+    "\n",
+    "analysis_prompt = ChatPromptTemplate.from_template(\"is this a funny joke? {joke}\")\n",
+    "\n",
+    "composed_chain = {\"joke\": chain} | analysis_prompt | model | StrOutputParser()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"That's a pretty classic and well-known bear pun joke. Whether it's considered funny is quite subjective, as humor is very personal. Some people may find that type of pun-based joke amusing, while others may not find it that humorous. Ultimately, the funniness of a joke is in the eye (or ear) of the beholder. If you enjoyed the joke and got a chuckle out of it, then that's what matters most.\""
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "composed_chain.invoke({\"topic\": \"bears\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Functions will also be coerced into runnables, so you can add custom logic to your chains too. The below chain results in the same logical flow as before:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "composed_chain_with_lambda = (\n",
+    "    chain\n",
+    "    | (lambda input: {\"joke\": input})\n",
+    "    | analysis_prompt\n",
+    "    | model\n",
+    "    | StrOutputParser()\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'I appreciate the effort, but I have to be honest - I didn\\'t find that joke particularly funny. Beet-themed puns can be quite hit-or-miss, and this one falls more on the \"miss\" side for me. The premise is a bit too straightforward and predictable. While I can see the logic behind it, the punchline just doesn\\'t pack much of a comedic punch. \\n\\nThat said, I do admire your willingness to explore puns and wordplay around vegetables. Cultivating a good sense of humor takes practice, and not every joke is going to land. The important thing is to keep experimenting and finding what works. Maybe try for a more unexpected or creative twist on beet-related humor next time. But thanks for sharing - I always appreciate when humans test out jokes on me, even if they don\\'t always make me laugh out loud.'"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "composed_chain_with_lambda.invoke({\"topic\": \"beets\"})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "However, keep in mind that using functions like this may interfere with operations like streaming. See [this section](/docs/expression_language/primitives/functions) for more information."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## The `.pipe()` method\n",
+    "\n",
+    "We could also compose the same sequence using the `.pipe()` method. Here's what that looks like:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain_core.runnables import RunnableParallel\n",
+    "\n",
+    "composed_chain_with_pipe = (\n",
+    "    RunnableParallel({\"joke\": chain})\n",
+    "    .pipe(analysis_prompt)\n",
+    "    .pipe(model)\n",
+    "    .pipe(StrOutputParser())\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'That\\'s a pretty good Battlestar Galactica-themed pun! I appreciated the clever play on words with \"Centurion\" and \"center on.\" It\\'s the kind of nerdy, science fiction-inspired humor that fans of the show would likely enjoy. The joke is clever and demonstrates a good understanding of the Battlestar Galactica universe. I\\'d be curious to hear any other Battlestar-related jokes you might have up your sleeve. As long as they don\\'t reproduce copyrighted material, I\\'m happy to provide my thoughts on the humor and appeal for fans of the show.'"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "composed_chain_with_pipe.invoke({\"topic\": \"battlestar galactica\"})"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

docs/docs/expression_language/streaming.ipynb

@@ -55,7 +55,7 @@
    "id": "9eb73e8b",
    "metadata": {},
    "source": [
-    "We will show examples of streaming using the chat model from [Anthropic](https://python.langchain.com/docs/integrations/platforms/anthropic). To use the model, you will need to install the `langchain-anthropic` package. You can do this with the following command:"
+    "We will show examples of streaming using the chat model from [Anthropic](/docs/integrations/platforms/anthropic). To use the model, you will need to install the `langchain-anthropic` package. You can do this with the following command:"
    ]
   },
   {
@@ -201,13 +201,23 @@
     "    print(chunk, end=\"|\", flush=True)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "868bc412",
+   "metadata": {},
+   "source": [
+    "You might notice above that `parser` actually doesn't block the streaming output from the model, and instead processes each chunk individually. Many of the [LCEL primitives](/docs/expression_language/primitives) also support this kind of transform-style passthrough streaming, which can be very convenient when constructing apps.\n",
+    "\n",
+    "Certain runnables, like [prompt templates](/docs/modules/model_io/prompts) and [chat models](/docs/modules/model_io/chat), cannot process individual chunks and instead aggregate all previous steps. This will interrupt the streaming process. Custom functions can be [designed to return generators](/docs/expression_language/primitives/functions#streaming), which"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "1b399fb4-5e3c-4581-9570-6df9b42b623d",
    "metadata": {},
    "source": [
     ":::{.callout-note}\n",
-    "You do not have to use the `LangChain Expression Language` to use LangChain and can instead rely on a standard **imperative** programming approach by\n",
+    "If the above functionality is not relevant to what you're building, you do not have to use the `LangChain Expression Language` to use LangChain and can instead 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",
     "If that works for your needs, then that's fine by us 👌!\n",
@@ -658,7 +668,7 @@
     "\n",
     "This is a **beta API**, and we're almost certainly going to make some changes to it.\n",
     "\n",
-    "This version parameter will allow us to mimimize such breaking changes to your code. \n",
+    "This version parameter will allow us to minimize such breaking changes to your code. \n",
     "\n",
     "In short, we are annoying you now, so we don't have to annoy you later.\n",
     ":::"

docs/docs/expression_language/why.ipynb

@@ -7,10 +7,12 @@
    "source": [
     "---\n",
     "sidebar_position: 0.5\n",
-    "title: Why use LCEL\n",
+    "title: Advantages of LCEL\n",
     "---\n",
     "\n",
-    "import { ColumnContainer, Column } from \\\"@theme/Columns\\\";"
+    "```{=mdx}\n",
+    "import { ColumnContainer, Column } from \"@theme/Columns\";\n",
+    "```"
    ]
   },
   {
@@ -18,7 +20,7 @@
    "id": "919a5ae2-ed21-4923-b98f-723c111bac67",
    "metadata": {},
    "source": [
-    ":::tip \n",
+    ":::{.callout-tip} \n",
     "We recommend reading the LCEL [Get started](/docs/expression_language/get_started) section first.\n",
     ":::"
    ]
@@ -28,17 +30,20 @@
    "id": "f331037f-be3f-4782-856f-d55dab952488",
    "metadata": {},
    "source": [
-    "LCEL makes it easy to build complex chains from basic components. It does this by providing:\n",
-    "1. **A unified interface**: Every LCEL object implements the `Runnable` interface, which defines a common set of invocation methods (`invoke`, `batch`, `stream`, `ainvoke`, ...). This makes it possible for chains of LCEL objects to also automatically support these invocations. That is, every chain of LCEL objects is itself an LCEL object.\n",
-    "2. **Composition primitives**: LCEL provides a number of primitives that make it easy to compose chains, parallelize components, add fallbacks, dynamically configure chain internal, and more.\n",
+    "LCEL is designed to streamline the process of building useful apps with LLMs and combining related components. It does this by providing:\n",
+    "\n",
+    "1. **A unified interface**: Every LCEL object implements the `Runnable` interface, which defines a common set of invocation methods (`invoke`, `batch`, `stream`, `ainvoke`, ...). This makes it possible for chains of LCEL objects to also automatically support useful operations like batching and streaming of intermediate steps, since every chain of LCEL objects is itself an LCEL object.\n",
+    "2. **Composition primitives**: LCEL provides a number of primitives that make it easy to compose chains, parallelize components, add fallbacks, dynamically configure chain internals, and more.\n",
     "\n",
     "To better understand the value of LCEL, it's helpful to see it in action and think about how we might recreate similar functionality without it. In this walkthrough we'll do just that with our [basic example](/docs/expression_language/get_started#basic_example) from the get started section. We'll take our simple prompt + model chain, which under the hood already defines a lot of functionality, and see what it would take to recreate all of it."
    ]
   },
   {
-   "cell_type": "raw",
+   "cell_type": "code",
+   "execution_count": null,
    "id": "b99b47ec",
    "metadata": {},
+   "outputs": [],
    "source": [
     "%pip install --upgrade --quiet  langchain-core langchain-openai langchain-anthropic"
    ]
@@ -51,10 +56,13 @@
     "## Invoke\n",
     "In the simplest case, we just want to pass in a topic string and get back a joke string:\n",
     "\n",
+    "```{=mdx}\n",
     "<ColumnContainer>\n",
     "\n",
     "<Column>\n",
     "\n",
+    "```\n",
+    "\n",
     "#### Without LCEL\n"
    ]
   },
@@ -93,9 +101,12 @@
    "id": "cdc3b527-c09e-4c77-9711-c3cc4506cd95",
    "metadata": {},
    "source": [
+    "\n",
+    "```{=mdx}\n",
     "</Column>\n",
     "\n",
     "<Column>\n",
+    "```\n",
     "\n",
     "#### LCEL\n",
     "\n"
@@ -134,14 +145,19 @@
    "id": "3c0b0513-77b8-4371-a20e-3e487cec7e7f",
    "metadata": {},
    "source": [
+    "\n",
+    "```{=mdx}\n",
     "</Column>\n",
     "</ColumnContainer>\n",
-    "\n",
+    "```\n",
     "## Stream\n",
     "If we want to stream results instead, we'll need to change our function:\n",
     "\n",
+    "```{=mdx}\n",
+    "\n",
     "<ColumnContainer>\n",
     "<Column>\n",
+    "```\n",
     "\n",
     "#### Without LCEL\n",
     "\n"
@@ -182,10 +198,11 @@
    "id": "f8e36b0e-c7dc-4130-a51b-189d4b756c7f",
    "metadata": {},
    "source": [
+    "```{=mdx}\n",
     "</Column>\n",
     "\n",
     "<Column>\n",
-    "\n",
+    "```\n",
     "#### LCEL\n",
     "\n"
    ]
@@ -206,15 +223,19 @@
    "id": "b9b41e78-ddeb-44d0-a58b-a0ea0c99a761",
    "metadata": {},
    "source": [
+    "```{=mdx}\n",
     "</Column>\n",
     "</ColumnContainer>\n",
+    "```\n",
     "\n",
     "## Batch\n",
     "\n",
     "If we want to run on a batch of inputs in parallel, we'll again need a new function:\n",
     "\n",
+    "```{=mdx}\n",
     "<ColumnContainer>\n",
     "<Column>\n",
+    "```\n",
     "\n",
     "#### Without LCEL\n",
     "\n"
@@ -242,10 +263,11 @@
    "id": "9b3e9d34-6775-43c1-93d8-684b58e341ab",
    "metadata": {},
    "source": [
+    "```{=mdx}\n",
     "</Column>\n",
     "\n",
     "<Column>\n",
-    "\n",
+    "```\n",
     "#### LCEL\n",
     "\n"
    ]
@@ -265,15 +287,18 @@
    "id": "cc5ba36f-eec1-4fc1-8cfe-fa242a7f7809",
    "metadata": {},
    "source": [
+    "```{=mdx}\n",
     "</Column>\n",
     "</ColumnContainer>\n",
-    "\n",
+    "```\n",
     "## Async\n",
     "\n",
     "If we need an asynchronous version:\n",
     "\n",
+    "```{=mdx}\n",
     "<ColumnContainer>\n",
     "<Column>\n",
+    "```\n",
     "\n",
     "#### Without LCEL\n",
     "\n"
@@ -298,7 +323,10 @@
     "async def ainvoke_chain(topic: str) -> str:\n",
     "    prompt_value = prompt_template.format(topic=topic)\n",
     "    messages = [{\"role\": \"user\", \"content\": prompt_value}]\n",
-    "    return await acall_chat_model(messages)"
+    "    return await acall_chat_model(messages)\n",
+    "\n",
+    "\n",
+    "await ainvoke_chain(\"ice cream\")"
    ]
   },
   {
@@ -306,19 +334,88 @@
    "id": "2f209290-498c-4c17-839e-ee9002919846",
    "metadata": {},
    "source": [
-    "```python\n",
-    "await ainvoke_chain(\"ice cream\")\n",
-    "```\n",
-    "\n",
+    "```{=mdx}\n",
     "</Column>\n",
     "\n",
     "<Column>\n",
+    "```\n",
     "\n",
     "#### LCEL\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4d009781-7307-48a4-8439-f9d3dd015560",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "await chain.ainvoke(\"ice cream\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1f282129-99a3-40f4-b67f-2d0718b1bea9",
+   "metadata": {},
+   "source": [
+    "```{=mdx}\n",
+    "</Column>\n",
+    "</ColumnContainer>\n",
+    "```\n",
+    "## Async Batch\n",
     "\n",
-    "```python\n",
-    "chain.ainvoke(\"ice cream\")\n",
-    "```"
+    "```{=mdx}\n",
+    "<ColumnContainer>\n",
+    "<Column>\n",
+    "```\n",
+    "\n",
+    "#### Without LCEL\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1933f39d-7bd7-45fa-a6a5-5fb7be8e31ec",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import asyncio\n",
+    "import openai\n",
+    "\n",
+    "\n",
+    "async def abatch_chain(topics: list) -> list:\n",
+    "    coros = map(ainvoke_chain, topics)\n",
+    "    return await asyncio.gather(*coros)\n",
+    "\n",
+    "\n",
+    "await abatch_chain([\"ice cream\", \"spaghetti\", \"dumplings\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "90691048-17ae-479d-83c2-859e33ddf3eb",
+   "metadata": {},
+   "source": [
+    "```{=mdx}\n",
+    "</Column>\n",
+    "\n",
+    "<Column>\n",
+    "```\n",
+    "\n",
+    "#### LCEL\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "947dad23-3443-40eb-a03b-7840c261e261",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "await chain.abatch([\"ice cream\", \"spaghetti\", \"dumplings\"])"
    ]
   },
   {
@@ -326,15 +423,19 @@
    "id": "f6888245-1ebe-4768-a53b-e1fef6a8b379",
    "metadata": {},
    "source": [
+    "```{=mdx}\n",
     "</Column>\n",
     "</ColumnContainer>\n",
+    "```\n",
     "\n",
     "## LLM instead of chat model\n",
     "\n",
     "If we want to use a completion endpoint instead of a chat endpoint: \n",
     "\n",
+    "```{=mdx}\n",
     "<ColumnContainer>\n",
     "<Column>\n",
+    "```\n",
     "\n",
     "#### Without LCEL\n",
     "\n"
@@ -366,9 +467,11 @@
    "id": "45342cd6-58c2-4543-9392-773e05ef06e7",
    "metadata": {},
    "source": [
+    "```{=mdx}\n",
     "</Column>\n",
     "\n",
     "<Column>\n",
+    "```\n",
     "\n",
     "#### LCEL\n",
     "\n"
@@ -399,15 +502,19 @@
    "id": "ca115eaf-59ef-45c1-aac1-e8b0ce7db250",
    "metadata": {},
    "source": [
+    "```{=mdx}\n",
     "</Column>\n",
     "</ColumnContainer>\n",
+    "```\n",
     "\n",
     "## Different model provider\n",
     "\n",
     "If we want to use Anthropic instead of OpenAI: \n",
     "\n",
+    "```{=mdx}\n",
     "<ColumnContainer>\n",
     "<Column>\n",
+    "```\n",
     "\n",
     "#### Without LCEL\n",
     "\n"
@@ -445,9 +552,11 @@
    "id": "52a0c9f8-e316-42e1-af85-cabeba4b7059",
    "metadata": {},
    "source": [
+    "```{=mdx}\n",
     "</Column>\n",
     "\n",
     "<Column>\n",
+    "```\n",
     "\n",
     "#### LCEL\n",
     "\n"
@@ -478,15 +587,19 @@
    "id": "d7a91eee-d017-420d-b215-f663dcbf8ed2",
    "metadata": {},
    "source": [
+    "```{=mdx}\n",
     "</Column>\n",
     "</ColumnContainer>\n",
+    "```\n",
     "\n",
     "## Runtime configurability\n",
     "\n",
     "If we wanted to make the choice of chat model or LLM configurable at runtime:\n",
     "\n",
+    "```{=mdx}\n",
     "<ColumnContainer>\n",
     "<Column>\n",
+    "```\n",
     "\n",
     "#### Without LCEL\n",
     "\n"
@@ -567,9 +680,11 @@
    "id": "d1530c5c-6635-4599-9483-6df357ca2d64",
    "metadata": {},
    "source": [
+    "```{=mdx}\n",
     "</Column>\n",
     "\n",
     "<Column>\n",
+    "```\n",
     "\n",
     "#### With LCEL\n",
     "\n"
@@ -627,15 +742,19 @@
    "id": "370dd4d7-b825-40c4-ae3c-2693cba2f22a",
    "metadata": {},
    "source": [
+    "```{=mdx}\n",
     "</Column>\n",
     "</ColumnContainer>\n",
+    "```\n",
     "\n",
     "## Logging\n",
     "\n",
     "If we want to log our intermediate results:\n",
     "\n",
+    "```{=mdx}\n",
     "<ColumnContainer>\n",
     "<Column>\n",
+    "```\n",
     "\n",
     "#### Without LCEL\n",
     "\n",
@@ -666,9 +785,11 @@
    "id": "16bd20fd-43cd-4aaf-866f-a53d1f20312d",
    "metadata": {},
    "source": [
+    "```{=mdx}\n",
     "</Column>\n",
     "\n",
     "<Column>\n",
+    "```\n",
     "\n",
     "#### LCEL\n",
     "Every component has built-in integrations with LangSmith. If we set the following two environment variables, all chain traces are logged to LangSmith.\n",
@@ -703,16 +824,19 @@
    "id": "e25ce3c5-27a7-4954-9f0e-b94313597135",
    "metadata": {},
    "source": [
+    "```{=mdx}\n",
     "</Column>\n",
     "</ColumnContainer>\n",
+    "```\n",
     "\n",
     "## Fallbacks\n",
     "\n",
     "If we wanted to add fallback logic, in case one model API is down:\n",
     "\n",
-    "\n",
+    "```{=mdx}\n",
     "<ColumnContainer>\n",
     "<Column>\n",
+    "```\n",
     "\n",
     "#### Without LCEL\n",
     "\n",
@@ -737,7 +861,7 @@
     "        return await ainvoke_chain(topic)\n",
     "    except Exception:\n",
     "        # Note: we haven't actually implemented this.\n",
-    "        return ainvoke_anthropic_chain(topic)\n",
+    "        return await ainvoke_anthropic_chain(topic)\n",
     "\n",
     "async def batch_chain_with_fallback(topics: List[str]) -> str:\n",
     "    try:\n",
@@ -756,9 +880,11 @@
    "id": "f7ef59b5-2ce3-479e-a7ac-79e1e2f30e9c",
    "metadata": {},
    "source": [
+    "```{=mdx}\n",
     "</Column>\n",
     "\n",
     "<Column>\n",
+    "```\n",
     "\n",
     "#### LCEL\n",
     "\n"
@@ -783,8 +909,10 @@
    "id": "3af52d36-37c6-4d89-b515-95d7270bb96a",
    "metadata": {},
    "source": [
+    "```{=mdx}\n",
     "</Column>\n",
-    "</ColumnContainer>"
+    "</ColumnContainer>\n",
+    "```"
    ]
   },
   {
@@ -796,8 +924,10 @@
     "\n",
     "Even in this simple case, our LCEL chain succinctly packs in a lot of functionality. As chains become more complex, this becomes especially valuable.\n",
     "\n",
+    "```{=mdx}\n",
     "<ColumnContainer>\n",
     "<Column>\n",
+    "```\n",
     "\n",
     "#### Without LCEL\n",
     "\n"
@@ -963,7 +1093,7 @@
     "    try:\n",
     "        return await ainvoke_chain(topic)\n",
     "    except Exception:\n",
-    "        return ainvoke_anthropic_chain(topic)\n",
+    "        return await ainvoke_anthropic_chain(topic)\n",
     "\n",
     "async def batch_chain_with_fallback(topics: List[str]) -> str:\n",
     "    try:\n",
@@ -977,9 +1107,11 @@
    "id": "9fb3d71d-8c69-4dc4-81b7-95cd46b271c2",
    "metadata": {},
    "source": [
+    "```{=mdx}\n",
     "</Column>\n",
     "\n",
     "<Column>\n",
+    "```\n",
     "\n",
     "#### LCEL\n",
     "\n"
@@ -1034,8 +1166,10 @@
    "id": "e3637d39",
    "metadata": {},
    "source": [
+    "```{=mdx}\n",
     "</Column>\n",
-    "</ColumnContainer>"
+    "</ColumnContainer>\n",
+    "```"
    ]
   },
   {
@@ -1047,8 +1181,7 @@
     "\n",
     "To continue learning about LCEL, we recommend:\n",
     "- Reading up on the full LCEL [Interface](/docs/expression_language/interface), which we've only partially covered here.\n",
-    "- Exploring the [How-to](/docs/expression_language/how_to) section to learn about additional composition primitives that LCEL provides.\n",
-    "- Looking through the [Cookbook](/docs/expression_language/cookbook) section to see LCEL in action for common use cases. A good next use case to look at would be [Retrieval-augmented generation](/docs/expression_language/cookbook/retrieval)."
+    "- Exploring the [primitives](/docs/expression_language/primitives) to learn more about what LCEL provides."
    ]
   }
  ],
@@ -1068,7 +1201,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.1"
+   "version": "3.11.6"
   }
  },
  "nbformat": 4,

docs/docs/get_started/installation.mdx

@@ -1,3 +1,7 @@
+---
+sidebar_position: 2
+---
+
 # Installation
 
 ## Official release
@@ -29,13 +33,6 @@ If you want to install from source, you can do so by cloning the repo and be sur
 pip install -e .
 ```
 
-## LangChain community
-The `langchain-community` package contains third-party integrations. It is automatically installed by `langchain`, but can also be used separately. Install with:
-
-```bash
-pip install langchain-community
-```
-
 ## LangChain core
 The `langchain-core` package contains base abstractions that the rest of the LangChain ecosystem uses, along with the LangChain Expression Language. It is automatically installed by `langchain`, but can also be used separately. Install with:
 
@@ -43,6 +40,13 @@ The `langchain-core` package contains base abstractions that the rest of the Lan
 pip install langchain-core
 ```
 
+## LangChain community
+The `langchain-community` package contains third-party integrations. It is automatically installed by `langchain`, but can also be used separately. Install with:
+
+```bash
+pip install langchain-community
+```
+
 ## LangChain experimental
 The `langchain-experimental` package holds experimental LangChain code, intended for research and experimental uses.
 Install with:
@@ -51,6 +55,13 @@ Install with:
 pip install langchain-experimental
 ```
 
+## LangGraph
+`langgraph` is a library for building stateful, multi-actor applications with LLMs, built on top of (and intended to be used with) LangChain.
+Install with:
+
+```bash
+pip install langgraph
+```
 ## LangServe
 LangServe helps developers deploy LangChain runnables and chains as a REST API.
 LangServe is automatically installed by LangChain CLI.

docs/docs/get_started/introduction.mdx

@@ -1,18 +1,16 @@
 ---
 sidebar_position: 0
+sidebar_class_name: hidden
 ---
 
 # Introduction
 
-**LangChain** is a framework for developing applications powered by language models. It enables applications that:
-- **Are context-aware**: connect a language model to sources of context (prompt instructions, few shot examples, content to ground its response in, etc.)
-- **Reason**: rely on a language model to reason (about how to answer based on provided context, what actions to take, etc.)
+**LangChain** is a framework for developing applications powered by large language models (LLMs).
 
-This framework consists of several parts.
-- **LangChain Libraries**: The Python and JavaScript libraries. Contains interfaces and integrations for a myriad of components, a basic run time for combining these components into chains and agents, and off-the-shelf implementations of chains and agents.
-- **[LangChain Templates](/docs/templates)**: A collection of easily deployable reference architectures for a wide variety of tasks.
-- **[LangServe](/docs/langserve)**: A library for deploying LangChain chains as a REST API.
-- **[LangSmith](/docs/langsmith)**: A developer platform that lets you debug, test, evaluate, and monitor chains built on any LLM framework and seamlessly integrates with LangChain.
+LangChain simplifies every stage of the LLM application lifecycle:
+- **Development**: Build your applications using LangChain's open-source [building blocks](/docs/expression_language/) and [components](/docs/modules/). Hit the ground running using [third-party integrations](/docs/integrations/platforms/) and [Templates](/docs/templates).
+- **Productionization**: Use [LangSmith](/docs/langsmith/) to inspect, monitor and evaluate your chains, so that you can continuously optimize and deploy with confidence.
+- **Deployment**: Turn any chain into an API with [LangServe](/docs/langserve).
 
 import ThemedImage from '@theme/ThemedImage';
 
@@ -25,31 +23,24 @@ import ThemedImage from '@theme/ThemedImage';
   title="LangChain Framework Overview"
 />
 
-Together, these products simplify the entire application lifecycle:
-- **Develop**: Write your applications in LangChain/LangChain.js. Hit the ground running using Templates for reference.
-- **Productionize**: Use LangSmith to inspect, test and monitor your chains, so that you can constantly improve and deploy with confidence.
-- **Deploy**: Turn any chain into an API with LangServe.
+Concretely, the framework consists of the following open-source libraries:
 
-## LangChain Libraries
-
-The main value props of the LangChain packages are:
-1. **Components**: composable tools and integrations for working with language models. Components are modular and easy-to-use, whether you are using the rest of the LangChain framework or not
-2. **Off-the-shelf chains**: built-in assemblages of components for accomplishing higher-level tasks
-
-Off-the-shelf chains make it easy to get started. Components make it easy to customize existing chains and build new ones.
-
-The LangChain libraries themselves are made up of several different packages.
 - **`langchain-core`**: Base abstractions and LangChain Expression Language.
 - **`langchain-community`**: Third party integrations.
+  - Partner packages (e.g. **`langchain-openai`**, **`langchain-anthropic`**, etc.): Some integrations have been further split into their own lightweight packages that only depend on **`langchain-core`**.
 - **`langchain`**: Chains, agents, and retrieval strategies that make up an application's cognitive architecture.
+- **[langgraph](/docs/langgraph)**: Build robust and stateful multi-actor applications with LLMs by modeling steps as edges and nodes in a graph.
+- **[langserve](/docs/langserve)**: Deploy LangChain chains as REST APIs.
+
+The broader ecosystem includes:
+
+- **[LangSmith](/docs/langsmith)**: A developer platform that lets you debug, test, evaluate, and monitor LLM applications and seamlessly integrates with LangChain.
 
 ## Get started
 
-[Here’s](/docs/get_started/installation) how to install LangChain, set up your environment, and start building.
-
 We recommend following our [Quickstart](/docs/get_started/quickstart) guide to familiarize yourself with the framework by building your first LangChain application.
 
-Read up on our [Security](/docs/security) best practices to make sure you're developing safely with LangChain.
+[See here](/docs/get_started/installation) for instructions on how to install LangChain, set up your environment, and start building.
 
 :::note
 
@@ -57,48 +48,53 @@ These docs focus on the Python LangChain library. [Head here](https://js.langcha
 
 :::
 
-## LangChain Expression Language (LCEL)
+## Use cases
 
-LCEL is a declarative way to compose chains. LCEL was designed from day 1 to support putting prototypes in production, with no code changes, from the simplest “prompt + LLM” chain to the most complex chains.
+If you're looking to build something specific or are more of a hands-on learner, check out our [use-cases](/docs/use_cases).
+They're walkthroughs and techniques for common end-to-end tasks, such as:
 
-- **[Overview](/docs/expression_language/)**: LCEL and its benefits
-- **[Interface](/docs/expression_language/interface)**: The standard interface for LCEL objects
-- **[How-to](/docs/expression_language/how_to)**: Key features of LCEL
-- **[Cookbook](/docs/expression_language/cookbook)**: Example code for accomplishing common tasks
-
-
-## Modules
-
-LangChain provides standard, extendable interfaces and integrations for the following modules:
-
-#### [Model I/O](/docs/modules/model_io/)
-Interface with language models
-
-#### [Retrieval](/docs/modules/data_connection/)
-Interface with application-specific data
-
-#### [Agents](/docs/modules/agents/)
-Let models choose which tools to use given high-level directives
-
-
-## Examples, ecosystem, and resources
-
-### [Use cases](/docs/use_cases/question_answering/)
-Walkthroughs and techniques for common end-to-end use cases, like:
-- [Document question answering](/docs/use_cases/question_answering/)
+- [Question answering with RAG](/docs/use_cases/question_answering/)
+- [Extracting structured output](/docs/use_cases/extraction/)
 - [Chatbots](/docs/use_cases/chatbots/)
-- [Analyzing structured data](/docs/use_cases/sql/)
-- and much more...
+- and more!
+
+
+## Expression Language
+
+LangChain Expression Language (LCEL) is the foundation of many of LangChain's components, and is a declarative way to compose chains. LCEL was designed from day 1 to support putting prototypes in production, with no code changes, from the simplest “prompt + LLM” chain to the most complex chains.
+
+- **[Get started](/docs/expression_language/)**: LCEL and its benefits
+- **[Runnable interface](/docs/expression_language/interface)**: The standard interface for LCEL objects
+- **[Primitives](/docs/expression_language/primitives)**: More on the primitives LCEL includes
+- and more!
+
+## Ecosystem
+
+### [🦜🛠️ LangSmith](/docs/langsmith)
+Trace and evaluate your language model applications and intelligent agents to help you move from prototype to production.
+
+### [🦜🕸️ LangGraph](/docs/langgraph)
+Build stateful, multi-actor applications with LLMs, built on top of (and intended to be used with) LangChain primitives.
+
+### [🦜🏓 LangServe](/docs/langserve)
+Deploy LangChain runnables and chains as REST APIs.
+
+## [Security](/docs/security)
+Read up on our [Security](/docs/security) best practices to make sure you're developing safely with LangChain.
+
+## Additional resources
+
+### [Components](/docs/modules/)
+LangChain provides standard, extendable interfaces and integrations for many different components, including:
 
 ### [Integrations](/docs/integrations/providers/)
 LangChain is part of a rich ecosystem of tools that integrate with our framework and build on top of it. Check out our growing list of [integrations](/docs/integrations/providers/).
 
-### [Guides](../guides/debugging.md)
+### [Guides](/docs/guides/)
 Best practices for developing with LangChain.
 
 ### [API reference](https://api.python.langchain.com)
 Head to the reference section for full documentation of all classes and methods in the LangChain and LangChain Experimental Python packages.
 
-### [Developer's guide](/docs/contributing)
+### [Contributing](/docs/contributing)
 Check out the developer's guide for guidelines on contributing and help getting your dev environment set up.
-

docs/docs/get_started/quickstart.mdx

@@ -1,3 +1,7 @@
+---
+sidebar_position: 1
+---
+
 # Quickstart
 
 In this quickstart we'll show you how to:
@@ -14,7 +18,7 @@ That's a fair amount to cover! Let's dive in.
 
 ### Jupyter Notebook
 
-This guide (and most of the other guides in the documentation) use [Jupyter notebooks](https://jupyter.org/) and assume the reader is as well. Jupyter notebooks are perfect for learning how to work with LLM systems because often times things can go wrong (unexpected output, API down, etc) and going through guides in an interactive environment is a great way to better understand them.
+This guide (and most of the other guides in the documentation) uses [Jupyter notebooks](https://jupyter.org/) and assumes the reader is as well. Jupyter notebooks are perfect for learning how to work with LLM systems because oftentimes things can go wrong (unexpected output, API down, etc) and going through guides in an interactive environment is a great way to better understand them.
 
 You do not NEED to go through the guide in a Jupyter Notebook, but it is recommended. See [here](https://jupyter.org/install) for instructions on how to install.
 
@@ -90,12 +94,12 @@ from langchain_openai import ChatOpenAI
 llm = ChatOpenAI()
 ```
 
-If you'd prefer not to set an environment variable you can pass the key in directly via the `openai_api_key` named parameter when initiating the OpenAI LLM class:
+If you'd prefer not to set an environment variable you can pass the key in directly via the `api_key` named parameter when initiating the OpenAI LLM class:
 
 ```python
 from langchain_openai import ChatOpenAI
 
-llm = ChatOpenAI(openai_api_key="...")
+llm = ChatOpenAI(api_key="...")
 ```
 
   </TabItem>
@@ -137,10 +141,10 @@ from langchain_anthropic import ChatAnthropic
 llm = ChatAnthropic(model="claude-3-sonnet-20240229", temperature=0.2, max_tokens=1024)
 ```
 
-If you'd prefer not to set an environment variable you can pass the key in directly via the `anthropic_api_key` named parameter when initiating the Anthropic Chat Model class:
+If you'd prefer not to set an environment variable you can pass the key in directly via the `api_key` named parameter when initiating the Anthropic Chat Model class:
 
 ```python
-llm = ChatAnthropic(anthropic_api_key="...")
+llm = ChatAnthropic(api_key="...")
 ```
 
   </TabItem>
@@ -149,7 +153,7 @@ llm = ChatAnthropic(anthropic_api_key="...")
 First we'll need to import the Cohere SDK package.
 
 ```shell
-pip install cohere
+pip install langchain-cohere
 ```
 
 Accessing the API requires an API key, which you can get by creating an account and heading [here](https://dashboard.cohere.com/api-keys). Once we have a key we'll want to set it as an environment variable by running:
@@ -161,7 +165,7 @@ export COHERE_API_KEY="..."
 We can then initialize the model:
 
 ```python
-from langchain_community.chat_models import ChatCohere
+from langchain_cohere import ChatCohere
 
 llm = ChatCohere()
 ```
@@ -169,7 +173,7 @@ llm = ChatCohere()
 If you'd prefer not to set an environment variable you can pass the key in directly via the `cohere_api_key` named parameter when initiating the Cohere LLM class:
 
 ```python
-from langchain_community.chat_models import ChatCohere
+from langchain_cohere import ChatCohere
 
 llm = ChatCohere(cohere_api_key="...")
 ```
@@ -184,8 +188,8 @@ Let's ask it what LangSmith is - this is something that wasn't present in the tr
 llm.invoke("how can langsmith help with testing?")
 ```
 
-We can also guide it's response with a prompt template.
-Prompt templates are used to convert raw user input to a better input to the LLM.
+We can also guide its response with a prompt template.
+Prompt templates convert raw user input to better input to the LLM.
 
 ```python
 from langchain_core.prompts import ChatPromptTemplate
@@ -234,7 +238,7 @@ We've now successfully set up a basic LLM chain. We only touched on the basics o
 
 ## Retrieval Chain
 
-In order to properly answer the original question ("how can langsmith help with testing?"), we need to provide additional context to the LLM.
+To properly answer the original question ("how can langsmith help with testing?"), we need to provide additional context to the LLM.
 We can do this via *retrieval*.
 Retrieval is useful when you have **too much data** to pass to the LLM directly.
 You can then use a retriever to fetch only the most relevant pieces and pass those in.
@@ -242,7 +246,7 @@ You can then use a retriever to fetch only the most relevant pieces and pass tho
 In this process, we will look up relevant documents from a *Retriever* and then pass them into the prompt.
 A Retriever can be backed by anything - a SQL table, the internet, etc - but in this instance we will populate a vector store and use that as a retriever. For more information on vectorstores, see [this documentation](/docs/modules/data_connection/vectorstores).
 
-First, we need to load the data that we want to index. In order to do this, we will use the WebBaseLoader. This requires installing [BeautifulSoup](https://beautiful-soup-4.readthedocs.io/en/latest/):
+First, we need to load the data that we want to index. To do this, we will use the WebBaseLoader. This requires installing [BeautifulSoup](https://beautiful-soup-4.readthedocs.io/en/latest/):
 
 ```shell
 pip install beautifulsoup4
@@ -286,7 +290,7 @@ embeddings = OllamaEmbeddings()
   </TabItem>
 <TabItem value="cohere" label="Cohere (API)" default>
 
-Make sure you have the `cohere` package installed an the appropriate environment variables set (these are the same as needed for the LLM).
+Make sure you have the `cohere` package installed and the appropriate environment variables set (these are the same as needed for the LLM).
 
 ```python
 from langchain_community.embeddings import CohereEmbeddings
@@ -349,7 +353,7 @@ document_chain.invoke({
 ```
 
 However, we want the documents to first come from the retriever we just set up.
-That way, for a given question we can use the retriever to dynamically select the most relevant documents and pass those in.
+That way, we can use the retriever to dynamically select the most relevant documents and pass those in for a given question.
 
 ```python
 from langchain.chains import create_retrieval_chain
@@ -395,12 +399,12 @@ from langchain_core.prompts import MessagesPlaceholder
 prompt = ChatPromptTemplate.from_messages([
     MessagesPlaceholder(variable_name="chat_history"),
     ("user", "{input}"),
-    ("user", "Given the above conversation, generate a search query to look up in order to get information relevant to the conversation")
+    ("user", "Given the above conversation, generate a search query to look up to get information relevant to the conversation")
 ])
 retriever_chain = create_history_aware_retriever(llm, retriever, prompt)
 ```
 
-We can test this out by passing in an instance where the user is asking a follow up question.
+We can test this out by passing in an instance where the user asks a follow-up question.
 
 ```python
 from langchain_core.messages import HumanMessage, AIMessage
@@ -411,7 +415,7 @@ retriever_chain.invoke({
     "input": "Tell me how"
 })
 ```
-You should see that this returns documents about testing in LangSmith. This is because the LLM generated a new query, combining the chat history with the follow up question.
+You should see that this returns documents about testing in LangSmith. This is because the LLM generated a new query, combining the chat history with the follow-up question.
 
 Now that we have this new retriever, we can create a new chain to continue the conversation with these retrieved documents in mind.
 
@@ -439,7 +443,7 @@ We can see that this gives a coherent answer - we've successfully turned our ret
 
 ## Agent
 
-We've so far create examples of chains - where each step is known ahead of time.
+We've so far created examples of chains - where each step is known ahead of time.
 The final thing we will create is an agent - where the LLM decides what steps to take.
 
 **NOTE: for this example we will only show how to create an agent using OpenAI models, as local models are not reliable enough yet.**
@@ -448,7 +452,7 @@ One of the first things to do when building an agent is to decide what tools it
 For this example, we will give the agent access to two tools:
 
 1. The retriever we just created. This will let it easily answer questions about LangSmith
-2. A search tool. This will let it easily answer questions that require up to date information.
+2. A search tool. This will let it easily answer questions that require up-to-date information.
 
 First, let's set up a tool for the retriever we just created:
 
@@ -488,6 +492,11 @@ Install langchain hub first
 ```bash
 pip install langchainhub
 ```
+Install the langchain-openai package
+To interact with OpenAI we need to use langchain-openai which connects with OpenAI SDK[https://github.com/langchain-ai/langchain/tree/master/libs/partners/openai].  
+```bash
+pip install langchain-openai
+```
 
 Now we can use it to get a predefined prompt
 
@@ -499,6 +508,8 @@ from langchain.agents import AgentExecutor
 
 # Get the prompt to use - you can modify this!
 prompt = hub.pull("hwchase17/openai-functions-agent")
+
+# You need to set OPENAI_API_KEY environment variable or pass it as argument `api_key`.
 llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
 agent = create_openai_functions_agent(llm, tools, prompt)
 agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
@@ -563,7 +574,6 @@ from langchain_community.vectorstores import FAISS
 from langchain_text_splitters import RecursiveCharacterTextSplitter
 from langchain.tools.retriever import create_retriever_tool
 from langchain_community.tools.tavily_search import TavilySearchResults
-from langchain_openai import ChatOpenAI
 from langchain import hub
 from langchain.agents import create_openai_functions_agent
 from langchain.agents import AgentExecutor

docs/docs/guides/development/debugging.md

@@ -8,11 +8,11 @@ Here are a few different tools and functionalities to aid in debugging.
 
 ## Tracing
 
-Platforms with tracing capabilities like [LangSmith](/docs/langsmith/) and [WandB](/docs/integrations/providers/wandb_tracing) are the most comprehensive solutions for debugging. These platforms make it easy to not only log and visualize LLM apps, but also to actively debug, test and refine them.
+Platforms with tracing capabilities like [LangSmith](/docs/langsmith/) are the most comprehensive solutions for debugging. These platforms make it easy to not only log and visualize LLM apps, but also to actively debug, test and refine them.
 
-For anyone building production-grade LLM applications, we highly recommend using a platform like this.
+When building production-grade LLM applications, platforms like this are essential.
 
-![Screenshot of the LangSmith debugging interface showing an AgentExecutor run with input and output details, and a run tree visualization.](../../static/img/run_details.png "LangSmith Debugging Interface")
+![Screenshot of the LangSmith debugging interface showing an AgentExecutor run with input and output details, and a run tree visualization.](../../../static/img/run_details.png "LangSmith Debugging Interface")
 
 ## `set_debug` and `set_verbose`
 
@@ -27,7 +27,7 @@ Let's suppose we have a simple agent, and want to visualize the actions it takes
 from langchain.agents import AgentType, initialize_agent, load_tools
 from langchain_openai import ChatOpenAI
 
-llm = ChatOpenAI(model_name="gpt-4", temperature=0)
+llm = ChatOpenAI(model="gpt-4", temperature=0)
 tools = load_tools(["ddg-search", "llm-math"], llm=llm)
 agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION)
 ```

docs/docs/guides/development/index.mdx

@@ -0,0 +1,13 @@
+---
+sidebar_position: 1
+sidebar_class_name: hidden
+---
+
+# Development
+
+This section contains guides with general information around building apps with LangChain.
+
+import DocCardList from "@theme/DocCardList";
+import { useCurrentSidebarCategory } from '@docusaurus/theme-common';
+
+<DocCardList items={useCurrentSidebarCategory().items.filter((item) => item.href !== "/docs/guides/development/")} />

docs/docs/guides/development/local_llms.ipynb

@@ -9,7 +9,7 @@
     "\n",
     "## Use case\n",
     "\n",
-    "The popularity of projects like [PrivateGPT](https://github.com/imartinez/privateGPT), [llama.cpp](https://github.com/ggerganov/llama.cpp), [GPT4All](https://github.com/nomic-ai/gpt4all), and [llamafile](https://github.com/Mozilla-Ocho/llamafile) underscore the demand to run LLMs locally (on your own device).\n",
+    "The popularity of projects like [PrivateGPT](https://github.com/imartinez/privateGPT), [llama.cpp](https://github.com/ggerganov/llama.cpp), [Ollama](https://github.com/ollama/ollama), [GPT4All](https://github.com/nomic-ai/gpt4all), [llamafile](https://github.com/Mozilla-Ocho/llamafile), and others underscore the demand to run LLMs locally (on your own device).\n",
     "\n",
     "This has at least two important benefits:\n",
     "\n",
@@ -32,7 +32,7 @@
     "1. `Base model`: What is the base-model and how was it trained?\n",
     "2. `Fine-tuning approach`: Was the base-model fine-tuned and, if so, what [set of instructions](https://cameronrwolfe.substack.com/p/beyond-llama-the-power-of-open-llms#%C2%A7alpaca-an-instruction-following-llama-model) was used?\n",
     "\n",
-    "![Image description](../../static/img/OSS_LLM_overview.png)\n",
+    "![Image description](../../../static/img/OSS_LLM_overview.png)\n",
     "\n",
     "The relative performance of these models can be assessed using several leaderboards, including:\n",
     "\n",
@@ -56,7 +56,7 @@
     "\n",
     "In particular, see [this excellent post](https://finbarr.ca/how-is-llama-cpp-possible/) on the importance of quantization.\n",
     "\n",
-    "![Image description](../../static/img/llama-memory-weights.png)\n",
+    "![Image description](../../../static/img/llama-memory-weights.png)\n",
     "\n",
     "With less precision, we radically decrease the memory needed to store the LLM in memory.\n",
     "\n",
@@ -64,7 +64,7 @@
     "\n",
     "A Mac M2 Max is 5-6x faster than a M1 for inference due to the larger GPU memory bandwidth.\n",
     "\n",
-    "![Image description](../../static/img/llama_t_put.png)\n",
+    "![Image description](../../../static/img/llama_t_put.png)\n",
     "\n",
     "## Quickstart\n",
     "\n",
@@ -98,7 +98,7 @@
     "from langchain_community.llms import Ollama\n",
     "\n",
     "llm = Ollama(model=\"llama2\")\n",
-    "llm(\"The first man on the moon was ...\")"
+    "llm.invoke(\"The first man on the moon was ...\")"
    ]
   },
   {
@@ -140,7 +140,7 @@
     "llm = Ollama(\n",
     "    model=\"llama2\", callback_manager=CallbackManager([StreamingStdOutCallbackHandler()])\n",
     ")\n",
-    "llm(\"The first man on the moon was ...\")"
+    "llm.invoke(\"The first man on the moon was ...\")"
    ]
   },
   {
@@ -226,7 +226,7 @@
     "from langchain_community.llms import Ollama\n",
     "\n",
     "llm = Ollama(model=\"llama2:13b\")\n",
-    "llm(\"The first man on the moon was ... think step by step\")"
+    "llm.invoke(\"The first man on the moon was ... think step by step\")"
    ]
   },
   {
@@ -369,7 +369,7 @@
     }
    ],
    "source": [
-    "llm(\"The first man on the moon was ... Let's think step by step\")"
+    "llm.invoke(\"The first man on the moon was ... Let's think step by step\")"
    ]
   },
   {
@@ -426,7 +426,7 @@
     }
    ],
    "source": [
-    "llm(\"The first man on the moon was ... Let's think step by step\")"
+    "llm.invoke(\"The first man on the moon was ... Let's think step by step\")"
    ]
   },
   {
@@ -546,7 +546,7 @@
    "source": [
     "from langchain.chains import LLMChain\n",
     "from langchain.chains.prompt_selector import ConditionalPromptSelector\n",
-    "from langchain.prompts import PromptTemplate\n",
+    "from langchain_core.prompts import PromptTemplate\n",
     "\n",
     "DEFAULT_LLAMA_SEARCH_PROMPT = PromptTemplate(\n",
     "    input_variables=[\"question\"],\n",

docs/docs/guides/index.mdx

@@ -0,0 +1,3 @@
+# Guides
+
+This section contains deeper dives into the LangChain framework and how to apply it.

docs/docs/guides/model_laboratory.ipynb

@@ -1,283 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "920a3c1a",
-   "metadata": {},
-   "source": [
-    "# Model comparison\n",
-    "\n",
-    "Constructing your language model application will likely involved choosing between many different options of prompts, models, and even chains to use. When doing so, you will want to compare these different options on different inputs in an easy, flexible, and intuitive way. \n",
-    "\n",
-    "LangChain provides the concept of a ModelLaboratory to test out and try different models."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "12ebae56",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%pip install --upgrade --quiet  langchain langchain-openai"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "ab9e95ad",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.model_laboratory import ModelLaboratory\n",
-    "from langchain.prompts import PromptTemplate\n",
-    "from langchain_community.llms import Cohere, HuggingFaceHub\n",
-    "from langchain_openai import OpenAI"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "3dd69cb4",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import getpass\n",
-    "import os\n",
-    "\n",
-    "# get a new token: https://dashboard.cohere.ai/\n",
-    "os.environ[\"COHERE_API_KEY\"] = getpass.getpass(\"Cohere API Key:\")\n",
-    "os.environ[\"OPENAI_API_KEY\"] = getpass.getpass(\"Open API Key:\")\n",
-    "os.environ[\"HUGGINGFACEHUB_API_TOKEN\"] = getpass.getpass(\"Hugging Face API Key:\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "32cb94e6",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "llms = [\n",
-    "    OpenAI(temperature=0),\n",
-    "    Cohere(temperature=0),\n",
-    "    HuggingFaceHub(repo_id=\"google/flan-t5-xl\", model_kwargs={\"temperature\": 1}),\n",
-    "]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "14cde09d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "model_lab = ModelLaboratory.from_llms(llms)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "f186c741",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u001b[1mInput:\u001b[0m\n",
-      "What color is a flamingo?\n",
-      "\n",
-      "\u001b[1mOpenAI\u001b[0m\n",
-      "Params: {'model': 'text-davinci-002', 'temperature': 0.0, 'max_tokens': 256, 'top_p': 1, 'frequency_penalty': 0, 'presence_penalty': 0, 'n': 1, 'best_of': 1}\n",
-      "\u001b[36;1m\u001b[1;3m\n",
-      "\n",
-      "Flamingos are pink.\u001b[0m\n",
-      "\n",
-      "\u001b[1mCohere\u001b[0m\n",
-      "Params: {'model': 'command-xlarge-20221108', 'max_tokens': 20, 'temperature': 0.0, 'k': 0, 'p': 1, 'frequency_penalty': 0, 'presence_penalty': 0}\n",
-      "\u001b[33;1m\u001b[1;3m\n",
-      "\n",
-      "Pink\u001b[0m\n",
-      "\n",
-      "\u001b[1mHuggingFaceHub\u001b[0m\n",
-      "Params: {'repo_id': 'google/flan-t5-xl', 'temperature': 1}\n",
-      "\u001b[38;5;200m\u001b[1;3mpink\u001b[0m\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "model_lab.compare(\"What color is a flamingo?\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "248b652a",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "prompt = PromptTemplate(\n",
-    "    template=\"What is the capital of {state}?\", input_variables=[\"state\"]\n",
-    ")\n",
-    "model_lab_with_prompt = ModelLaboratory.from_llms(llms, prompt=prompt)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "f64377ac",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u001b[1mInput:\u001b[0m\n",
-      "New York\n",
-      "\n",
-      "\u001b[1mOpenAI\u001b[0m\n",
-      "Params: {'model': 'text-davinci-002', 'temperature': 0.0, 'max_tokens': 256, 'top_p': 1, 'frequency_penalty': 0, 'presence_penalty': 0, 'n': 1, 'best_of': 1}\n",
-      "\u001b[36;1m\u001b[1;3m\n",
-      "\n",
-      "The capital of New York is Albany.\u001b[0m\n",
-      "\n",
-      "\u001b[1mCohere\u001b[0m\n",
-      "Params: {'model': 'command-xlarge-20221108', 'max_tokens': 20, 'temperature': 0.0, 'k': 0, 'p': 1, 'frequency_penalty': 0, 'presence_penalty': 0}\n",
-      "\u001b[33;1m\u001b[1;3m\n",
-      "\n",
-      "The capital of New York is Albany.\u001b[0m\n",
-      "\n",
-      "\u001b[1mHuggingFaceHub\u001b[0m\n",
-      "Params: {'repo_id': 'google/flan-t5-xl', 'temperature': 1}\n",
-      "\u001b[38;5;200m\u001b[1;3mst john s\u001b[0m\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "model_lab_with_prompt.compare(\"New York\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "54336dbf",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.chains import SelfAskWithSearchChain\n",
-    "from langchain_community.utilities import SerpAPIWrapper\n",
-    "\n",
-    "open_ai_llm = OpenAI(temperature=0)\n",
-    "search = SerpAPIWrapper()\n",
-    "self_ask_with_search_openai = SelfAskWithSearchChain(\n",
-    "    llm=open_ai_llm, search_chain=search, verbose=True\n",
-    ")\n",
-    "\n",
-    "cohere_llm = Cohere(temperature=0)\n",
-    "search = SerpAPIWrapper()\n",
-    "self_ask_with_search_cohere = SelfAskWithSearchChain(\n",
-    "    llm=cohere_llm, search_chain=search, verbose=True\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "6a50a9f1",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "chains = [self_ask_with_search_openai, self_ask_with_search_cohere]\n",
-    "names = [str(open_ai_llm), str(cohere_llm)]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "d3549e99",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "model_lab = ModelLaboratory(chains, names=names)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "362f7f57",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u001b[1mInput:\u001b[0m\n",
-      "What is the hometown of the reigning men's U.S. Open champion?\n",
-      "\n",
-      "\u001b[1mOpenAI\u001b[0m\n",
-      "Params: {'model': 'text-davinci-002', 'temperature': 0.0, 'max_tokens': 256, 'top_p': 1, 'frequency_penalty': 0, 'presence_penalty': 0, 'n': 1, 'best_of': 1}\n",
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new chain...\u001b[0m\n",
-      "What is the hometown of the reigning men's U.S. Open champion?\n",
-      "Are follow up questions needed here:\u001b[32;1m\u001b[1;3m Yes.\n",
-      "Follow up: Who is the reigning men's U.S. Open champion?\u001b[0m\n",
-      "Intermediate answer: \u001b[33;1m\u001b[1;3mCarlos Alcaraz.\u001b[0m\u001b[32;1m\u001b[1;3m\n",
-      "Follow up: Where is Carlos Alcaraz from?\u001b[0m\n",
-      "Intermediate answer: \u001b[33;1m\u001b[1;3mEl Palmar, Spain.\u001b[0m\u001b[32;1m\u001b[1;3m\n",
-      "So the final answer is: El Palmar, Spain\u001b[0m\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n",
-      "\u001b[36;1m\u001b[1;3m\n",
-      "So the final answer is: El Palmar, Spain\u001b[0m\n",
-      "\n",
-      "\u001b[1mCohere\u001b[0m\n",
-      "Params: {'model': 'command-xlarge-20221108', 'max_tokens': 256, 'temperature': 0.0, 'k': 0, 'p': 1, 'frequency_penalty': 0, 'presence_penalty': 0}\n",
-      "\n",
-      "\n",
-      "\u001b[1m> Entering new chain...\u001b[0m\n",
-      "What is the hometown of the reigning men's U.S. Open champion?\n",
-      "Are follow up questions needed here:\u001b[32;1m\u001b[1;3m Yes.\n",
-      "Follow up: Who is the reigning men's U.S. Open champion?\u001b[0m\n",
-      "Intermediate answer: \u001b[33;1m\u001b[1;3mCarlos Alcaraz.\u001b[0m\u001b[32;1m\u001b[1;3m\n",
-      "So the final answer is:\n",
-      "\n",
-      "Carlos Alcaraz\u001b[0m\n",
-      "\u001b[1m> Finished chain.\u001b[0m\n",
-      "\u001b[33;1m\u001b[1;3m\n",
-      "So the final answer is:\n",
-      "\n",
-      "Carlos Alcaraz\u001b[0m\n",
-      "\n"
-     ]
-    }
-   ],
-   "source": [
-    "model_lab.compare(\"What is the hometown of the reigning men's U.S. Open champion?\")"
-   ]
-  }
- ],
- "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.11.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

docs/docs/guides/privacy/_category_.yml

@@ -1 +0,0 @@
-label: 'Privacy'

docs/docs/guides/productionization/evaluation/comparison/index.mdx

@@ -17,7 +17,7 @@ Here's a summary of the key methods and properties of a comparison evaluator:
 - `requires_reference`: This property specifies whether this evaluator requires a reference label.
 
 :::note LangSmith Support
-The [run_on_dataset](https://api.python.langchain.com/en/latest/api_reference.html#module-langchain.smith) evaluation method is designed to evaluate only a single model at a time, and thus, doesn't support these evaluators.
+The [run_on_dataset](https://api.python.langchain.com/en/latest/langchain_api_reference.html#module-langchain.smith) evaluation method is designed to evaluate only a single model at a time, and thus, doesn't support these evaluators.
 :::
 
 Detailed information about creating custom evaluators and the available built-in comparison evaluators is provided in the following sections.

docs/docs/guides/productionization/evaluation/comparison/pairwise_string.ipynb

@@ -294,7 +294,7 @@
    },
    "outputs": [],
    "source": [
-    "from langchain.prompts import PromptTemplate\n",
+    "from langchain_core.prompts import PromptTemplate\n",
     "\n",
     "prompt_template = PromptTemplate.from_template(\n",
     "    \"\"\"Given the input context, which do you prefer: A or B?\n",

docs/docs/guides/productionization/evaluation/index.mdx

@@ -7,23 +7,24 @@ Building applications with language models involves many moving parts. One of th
 The guides in this section review the APIs and functionality LangChain provides to help you better evaluate your applications. Evaluation and testing are both critical when thinking about deploying LLM applications, since production environments require repeatable and useful outcomes.
 
 LangChain offers various types of evaluators to help you measure performance and integrity on diverse data, and we hope to encourage the community to create and share other useful evaluators so everyone can improve. These docs will introduce the evaluator types, how to use them, and provide some examples of their use in real-world scenarios.
+These built-in evaluators all integrate smoothly with [LangSmith](/docs/langsmith), and allow you to create feedback loops that improve your application over time and prevent regressions.
 
 Each evaluator type in LangChain comes with ready-to-use implementations and an extensible API that allows for customization according to your unique requirements. Here are some of the types of evaluators we offer:
 
-- [String Evaluators](/docs/guides/evaluation/string/): These evaluators assess the predicted string for a given input, usually comparing it against a reference string.
-- [Trajectory Evaluators](/docs/guides/evaluation/trajectory/): These are used to evaluate the entire trajectory of agent actions.
-- [Comparison Evaluators](/docs/guides/evaluation/comparison/): These evaluators are designed to compare predictions from two runs on a common input.
+- [String Evaluators](/docs/guides/productionization/evaluation/string/): These evaluators assess the predicted string for a given input, usually comparing it against a reference string.
+- [Trajectory Evaluators](/docs/guides/productionization/evaluation/trajectory/): These are used to evaluate the entire trajectory of agent actions.
+- [Comparison Evaluators](/docs/guides/productionization/evaluation/comparison/): These evaluators are designed to compare predictions from two runs on a common input.
 
 These evaluators can be used across various scenarios and can be applied to different chain and LLM implementations in the LangChain library.
 
 We also are working to share guides and cookbooks that demonstrate how to use these evaluators in real-world scenarios, such as:
 
-- [Chain Comparisons](/docs/guides/evaluation/examples/comparisons): This example uses a comparison evaluator to predict the preferred output. It reviews ways to measure confidence intervals to select statistically significant differences in aggregate preference scores across different models or prompts.
+- [Chain Comparisons](/docs/guides/productionization/evaluation/examples/comparisons): This example uses a comparison evaluator to predict the preferred output. It reviews ways to measure confidence intervals to select statistically significant differences in aggregate preference scores across different models or prompts.
 
 
 ## LangSmith Evaluation
 
-LangSmith provides an integrated evaluation and tracing framework that allows you to check for regressions, compare systems, and easily identify and fix any sources of errors and performance issues. Check out the docs on [LangSmith Evaluation](https://docs.smith.langchain.com/category/testing--evaluation) and additional [cookbooks](https://docs.smith.langchain.com/category/langsmith-cookbook) for more detailed information on evaluating your applications.
+LangSmith provides an integrated evaluation and tracing framework that allows you to check for regressions, compare systems, and easily identify and fix any sources of errors and performance issues. Check out the docs on [LangSmith Evaluation](https://docs.smith.langchain.com/evaluation) and additional [cookbooks](https://docs.smith.langchain.com/cookbook) for more detailed information on evaluating your applications.
 
 ## LangChain benchmarks
 
@@ -37,6 +38,6 @@ Check out the docs for examples and leaderboard information.
 
 ## Reference Docs
 
-For detailed information on the available evaluators, including how to instantiate, configure, and customize them, check out the [reference documentation](https://api.python.langchain.com/en/latest/api_reference.html#module-langchain.evaluation) directly.
+For detailed information on the available evaluators, including how to instantiate, configure, and customize them, check out the [reference documentation](https://api.python.langchain.com/en/latest/langchain_api_reference.html#module-langchain.evaluation) directly.
 
 <DocCardList />