0dd9e865f71b47952a3b2cdb125f6a3c1a51600caa92c71cc0d8345033143a8e

langchain_md_files/contributing/code/setup.mdx

@@ -1,213 +0,0 @@
-# Setup
-
-This guide walks through how to run the repository locally and check in your first code.
-For a [development container](https://containers.dev/), see the [.devcontainer folder](https://github.com/langchain-ai/langchain/tree/master/.devcontainer).
-
-## Dependency Management: Poetry and other env/dependency managers
-
-This project utilizes [Poetry](https://python-poetry.org/) v1.7.1+ as a dependency manager.
-
-❗Note: *Before installing Poetry*, if you use `Conda`, create and activate a new Conda env (e.g. `conda create -n langchain python=3.9`)
-
-Install Poetry: **[documentation on how to install it](https://python-poetry.org/docs/#installation)**.
-
-❗Note: If you use `Conda` or `Pyenv` as your environment/package manager, after installing Poetry,
-tell Poetry to use the virtualenv python environment (`poetry config virtualenvs.prefer-active-python true`)
-
-## Different packages
-
-This repository contains multiple packages:
-- `langchain-core`: Base interfaces for key abstractions as well as logic for combining them in chains (LangChain Expression Language).
-- `langchain-community`: Third-party integrations of various components.
-- `langchain`: Chains, agents, and retrieval logic that makes up the cognitive architecture of your applications.
-- `langchain-experimental`: Components and chains that are experimental, either in the sense that the techniques are novel and still being tested, or they require giving the LLM more access than would be possible in most production systems.
-- Partner integrations: Partner packages in `libs/partners` that are independently version controlled.
-
-Each of these has its own development environment. Docs are run from the top-level makefile, but development
-is split across separate test & release flows.
-
-For this quickstart, start with langchain-community:
-
-```bash
-cd libs/community
-```
-
-## Local Development Dependencies
-
-Install langchain-community development requirements (for running langchain, running examples, linting, formatting, tests, and coverage):
-
-```bash
-poetry install --with lint,typing,test,test_integration
-```
-
-Then verify dependency installation:
-
-```bash
-make test
-```
-
-If during installation you receive a `WheelFileValidationError` for `debugpy`, please make sure you are running
-Poetry v1.6.1+. This bug was present in older versions of Poetry (e.g. 1.4.1) and has been resolved in newer releases.
-If you are still seeing this bug on v1.6.1+, you may also try disabling "modern installation"
-(`poetry config installer.modern-installation false`) and re-installing requirements.
-See [this `debugpy` issue](https://github.com/microsoft/debugpy/issues/1246) for more details.
-
-## Testing
-
-**Note:** In `langchain`, `langchain-community`, and `langchain-experimental`, some test dependencies are optional. See the following section about optional dependencies.
-
-Unit tests cover modular logic that does not require calls to outside APIs.
-If you add new logic, please add a unit test.
-
-To run unit tests:
-
-```bash
-make test
-```
-
-To run unit tests in Docker:
-
-```bash
-make docker_tests
-```
-
-There are also [integration tests and code-coverage](/docs/contributing/testing/) available.
-
-### Only develop langchain_core or langchain_experimental
-
-If you are only developing `langchain_core` or `langchain_experimental`, you can simply install the dependencies for the respective projects and run tests:
-
-```bash
-cd libs/core
-poetry install --with test
-make test
-```
-
-Or:
-
-```bash
-cd libs/experimental
-poetry install --with test
-make test
-```
-
-## Formatting and Linting
-
-Run these locally before submitting a PR; the CI system will check also.
-
-### Code Formatting
-
-Formatting for this project is done via [ruff](https://docs.astral.sh/ruff/rules/).
-
-To run formatting for docs, cookbook and templates:
-
-```bash
-make format
-```
-
-To run formatting for a library, run the same command from the relevant library directory:
-
-```bash
-cd libs/{LIBRARY}
-make format
-```
-
-Additionally, you can run the formatter only on the files that have been modified in your current branch as compared to the master branch using the format_diff command:
-
-```bash
-make format_diff
-```
-
-This is especially useful when you have made changes to a subset of the project and want to ensure your changes are properly formatted without affecting the rest of the codebase.
-
-#### Linting
-
-Linting for this project is done via a combination of [ruff](https://docs.astral.sh/ruff/rules/) and [mypy](http://mypy-lang.org/).
-
-To run linting for docs, cookbook and templates:
-
-```bash
-make lint
-```
-
-To run linting for a library, run the same command from the relevant library directory:
-
-```bash
-cd libs/{LIBRARY}
-make lint
-```
-
-In addition, you can run the linter only on the files that have been modified in your current branch as compared to the master branch using the lint_diff command:
-
-```bash
-make lint_diff
-```
-
-This can be very helpful when you've made changes to only certain parts of the project and want to ensure your changes meet the linting standards without having to check the entire codebase.
-
-We recognize linting can be annoying - if you do not want to do it, please contact a project maintainer, and they can help you with it. We do not want this to be a blocker for good code getting contributed.
-
-### Spellcheck
-
-Spellchecking for this project is done via [codespell](https://github.com/codespell-project/codespell).
-Note that `codespell` finds common typos, so it could have false-positive (correctly spelled but rarely used) and false-negatives (not finding misspelled) words.
-
-To check spelling for this project:
-
-```bash
-make spell_check
-```
-
-To fix spelling in place:
-
-```bash
-make spell_fix
-```
-
-If codespell is incorrectly flagging a word, you can skip spellcheck for that word by adding it to the codespell config in the `pyproject.toml` file.
-
-```python
-[tool.codespell]
-...
-# Add here:
-ignore-words-list = 'momento,collison,ned,foor,reworkd,parth,whats,aapply,mysogyny,unsecure'
-```
-
-## Working with Optional Dependencies
-
-`langchain`, `langchain-community`, and `langchain-experimental` rely on optional dependencies to keep these packages lightweight.
-
-`langchain-core` and partner packages **do not use** optional dependencies in this way.
-
-You'll notice that `pyproject.toml` and `poetry.lock` are **not** touched when you add optional dependencies below.
-
-If you're adding a new dependency to Langchain, assume that it will be an optional dependency, and
-that most users won't have it installed.
-
-Users who do not have the dependency installed should be able to **import** your code without
-any side effects (no warnings, no errors, no exceptions).
-
-To introduce the dependency to a library, please do the following:
-
-1. Open extended_testing_deps.txt and add the dependency
-2. Add a unit test that the very least attempts to import the new code. Ideally, the unit
-test makes use of lightweight fixtures to test the logic of the code.
-3. Please use the `@pytest.mark.requires(package_name)` decorator for any unit tests that require the dependency.
-
-## Adding a Jupyter Notebook
-
-If you are adding a Jupyter Notebook example, you'll want to install the optional `dev` dependencies.
-
-To install dev dependencies:
-
-```bash
-poetry install --with dev
-```
-
-Launch a notebook:
-
-```bash
-poetry run jupyter notebook
-```
-
-When you run `poetry install`, the `langchain` package is installed as editable in the virtualenv, so your new logic can be imported into the notebook.

langchain_md_files/contributing/documentation/index.mdx

@@ -1,7 +0,0 @@
-# Contribute Documentation
-
-Documentation is a vital part of LangChain. We welcome both new documentation for new features and 
-community improvements to our current documentation. Please read the resources below before getting started:
-
-- [Documentation style guide](/docs/contributing/documentation/style_guide/)
-- [Setup](/docs/contributing/documentation/setup/)

langchain_md_files/contributing/documentation/setup.mdx

@@ -1,181 +0,0 @@
----
-sidebar_class_name: "hidden"
----
-
-# Setup
-
-LangChain documentation consists of two components:
-
-1. Main Documentation: Hosted at [python.langchain.com](https://python.langchain.com/),
-this comprehensive resource serves as the primary user-facing documentation.
-It covers a wide array of topics, including tutorials, use cases, integrations,
-and more, offering extensive guidance on building with LangChain.
-The content for this documentation lives in the `/docs` directory of the monorepo.
-2. In-code Documentation: This is documentation of the codebase itself, which is also
-used to generate the externally facing [API Reference](https://python.langchain.com/v0.2/api_reference/langchain/index.html).
-The content for the API reference is autogenerated by scanning the docstrings in the codebase. For this reason we ask that
-developers document their code well.
-
-The `API Reference` is largely autogenerated by [sphinx](https://www.sphinx-doc.org/en/master/)
-from the code and is hosted by [Read the Docs](https://readthedocs.org/).
-
-We appreciate all contributions to the documentation, whether it be fixing a typo,
-adding a new tutorial or example and whether it be in the main documentation or the API Reference.
-
-Similar to linting, we recognize documentation can be annoying. If you do not want
-to do it, please contact a project maintainer, and they can help you with it. We do not want this to be a blocker for good code getting contributed.
-
-## 📜 Main Documentation
-
-The content for the main documentation is located in the `/docs` directory of the monorepo.
-
-The documentation is written using a combination of ipython notebooks (`.ipynb` files)
-and markdown (`.mdx` files). The notebooks are converted to markdown
-and then built using [Docusaurus 2](https://docusaurus.io/).
-
-Feel free to make contributions to the main documentation! 🥰
-
-After modifying the documentation:
-
-1. Run the linting and formatting commands (see below) to ensure that the documentation is well-formatted and free of errors.
-2. Optionally build the documentation locally to verify that the changes look good.
-3. Make a pull request with the changes.
-4. You can preview and verify that the changes are what you wanted by clicking the `View deployment` or `Visit Preview` buttons on the pull request `Conversation` page. This will take you to a preview of the documentation changes.
-
-## ⚒️ Linting and Building Documentation Locally
-
-After writing up the documentation, you may want to lint and build the documentation
-locally to ensure that it looks good and is free of errors.
-
-If you're unable to build it locally that's okay as well, as you will be able to
-see a preview of the documentation on the pull request page.
-
-From the **monorepo root**, run the following command to install the dependencies:
-
-```bash
-poetry install --with lint,docs --no-root
-````
-
-### Building
-
-The code that builds the documentation is located in the `/docs` directory of the monorepo.
-
-In the following commands, the prefix `api_` indicates that those are operations for the API Reference.
-
-Before building the documentation, it is always a good idea to clean the build directory:
-
-```bash
-make docs_clean
-make api_docs_clean
-```
-
-Next, you can build the documentation as outlined below:
-
-```bash
-make docs_build
-make api_docs_build
-```
-
-:::tip
-
-The `make api_docs_build` command takes a long time. If you're making cosmetic changes to the API docs and want to see how they look, use:
-
-```bash
-make api_docs_quick_preview
-```
-
-which will just build a small subset of the API reference.
-
-:::
-
-Finally, run the link checker to ensure all links are valid:
-
-```bash
-make docs_linkcheck
-make api_docs_linkcheck
-```
-
-### Linting and Formatting
-
-The Main Documentation is linted from the **monorepo root**. To lint the main documentation, run the following from there:
-
-```bash
-make lint
-```
-
-If you have formatting-related errors, you can fix them automatically with:
-
-```bash
-make format
-```
-
-## ⌨️ In-code Documentation
-
-The in-code documentation is largely autogenerated by [sphinx](https://www.sphinx-doc.org/en/master/) from the code and is hosted by [Read the Docs](https://readthedocs.org/).
-
-For the API reference to be useful, the codebase must be well-documented. This means that all functions, classes, and methods should have a docstring that explains what they do, what the arguments are, and what the return value is. This is a good practice in general, but it is especially important for LangChain because the API reference is the primary resource for developers to understand how to use the codebase.
-
-We generally follow the [Google Python Style Guide](https://google.github.io/styleguide/pyguide.html#38-comments-and-docstrings) for docstrings.
-
-Here is an example of a well-documented function:
-
-```python
-
-def my_function(arg1: int, arg2: str) -> float:
-    """This is a short description of the function. (It should be a single sentence.)
-
-    This is a longer description of the function. It should explain what
-    the function does, what the arguments are, and what the return value is.
-    It should wrap at 88 characters.
-
-    Examples:
-        This is a section for examples of how to use the function.
-
-        .. code-block:: python
-
-            my_function(1, "hello")
-
-    Args:
-        arg1: This is a description of arg1. We do not need to specify the type since
-            it is already specified in the function signature.
-        arg2: This is a description of arg2.
-
-    Returns:
-        This is a description of the return value.
-    """
-    return 3.14
-```
-
-### Linting and Formatting
-
-The in-code documentation is linted from the directories belonging to the packages
-being documented.
-
-For example, if you're working on the `langchain-community` package, you would change
-the working directory to the `langchain-community` directory:
-
-```bash
-cd [root]/libs/langchain-community
-```
-
-Set up a virtual environment for the package if you haven't done so already.
-
-Install the dependencies for the package.
-
-```bash
-poetry install --with lint
-```
-
-Then you can run the following commands to lint and format the in-code documentation:
-
-```bash
-make format
-make lint
-```
-
-## Verify Documentation Changes
-
-After pushing documentation changes to the repository, you can preview and verify that the changes are
-what you wanted by clicking the `View deployment` or `Visit Preview` buttons on the pull request `Conversation` page.
-This will take you to a preview of the documentation changes.
-This preview is created by [Vercel](https://vercel.com/docs/getting-started-with-vercel).

langchain_md_files/contributing/documentation/style_guide.mdx

@@ -1,160 +0,0 @@
----
-sidebar_class_name: "hidden"
----
-
-# Documentation Style Guide
-
-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 follows the [Diataxis framework](https://diataxis.fr).
-Under this framework, all documentation falls under one of four categories: [Tutorials](/docs/contributing/documentation/style_guide/#tutorials),
-[How-to guides](/docs/contributing/documentation/style_guide/#how-to-guides),
-[References](/docs/contributing/documentation/style_guide/#references), and [Explanations](/docs/contributing/documentation/style_guide/#conceptual-guide).
-
-### Tutorials
-
-Tutorials are lessons that take the reader through a practical activity. Their purpose is to help the user
-gain understanding of concepts and how they interact by showing one way to achieve some goal in a hands-on way. They should **avoid** giving
-multiple permutations of ways to achieve that goal in-depth. Instead, it should guide a new user through a recommended path to accomplishing the tutorial's goal. While the end result of a tutorial does not necessarily need to
-be completely production-ready, it should be useful and practically satisfy the the goal that you clearly stated in the tutorial's introduction. Information on how to address additional scenarios
-belongs in how-to guides.
-
-To quote the Diataxis website:
-
-> A tutorial serves the user’s *acquisition* of skills and knowledge - their study. Its purpose is not to help the user get something done, but to help them learn.
-
-In LangChain, these are often higher level guides that show off end-to-end use cases.
-
-Some examples include:
-
-- [Build a Simple LLM Application with LCEL](/docs/tutorials/llm_chain/)
-- [Build a Retrieval Augmented Generation (RAG) App](/docs/tutorials/rag/)
-
-A good structural rule of thumb is to follow the structure of this [example from Numpy](https://numpy.org/numpy-tutorials/content/tutorial-svd.html).
-  
-Here are some high-level tips on writing a good tutorial:
-
-- Focus on guiding the user to get something done, but keep in mind the end-goal is more to impart principles than to create a perfect production system.
-- Be specific, not abstract and follow one path.
-  - No need to go deeply into alternative approaches, but it’s ok to reference them, ideally with a link to an appropriate how-to guide.
-- Get "a point on the board" as soon as possible - something the user can run that outputs something.
-  - You can iterate and expand afterwards.
-  - Try to frequently checkpoint at given steps where the user can run code and see progress.
-- Focus on results, not technical explanation.
-  - Crosslink heavily to appropriate conceptual/reference pages.
-- The first time you mention a LangChain concept, use its full name (e.g. "LangChain Expression Language (LCEL)"), and link to its conceptual/other documentation page.
-  - It's also helpful to add a prerequisite callout that links to any pages with necessary background information.
-- End with a recap/next steps section summarizing what the tutorial covered and future reading, such as related how-to guides.
-  
-### How-to guides
-
-A how-to guide, as the name implies, demonstrates how to do something discrete and specific.
-It should assume that the user is already familiar with underlying concepts, and is trying to solve an immediate problem, but
-should still give some background or list the scenarios where the information contained within can be relevant.
-They can and should discuss alternatives if one approach may be better than another in certain cases.
-
-To quote the Diataxis website:
-
-> A how-to guide serves the work of the already-competent user, whom you can assume to know what they want to do, and to be able to follow your instructions correctly.
-
-Some examples include:
-
-- [How to: return structured data from a model](/docs/how_to/structured_output/)
-- [How to: write a custom chat model](/docs/how_to/custom_chat_model/)
-
-Here are some high-level tips on writing a good how-to guide:
-
-- Clearly explain what you are guiding the user through at the start.
-- Assume higher intent than a tutorial and show what the user needs to do to get that task done.
-- Assume familiarity of concepts, but explain why suggested actions are helpful.
-  - Crosslink heavily to conceptual/reference pages.
-- Discuss alternatives and responses to real-world tradeoffs that may arise when solving a problem.
-- Use lots of example code.
-  - Prefer full code blocks that the reader can copy and run.
-- End with a recap/next steps section summarizing what the tutorial covered and future reading, such as other related how-to guides.
-
-### Conceptual guide
-
-LangChain's conceptual guide falls under the **Explanation** quadrant of Diataxis. They should cover LangChain terms and concepts
-in a more abstract way than how-to guides or tutorials, and should be geared towards curious users interested in
-gaining a deeper understanding of the framework. Try to avoid excessively large code examples - the goal here is to
-impart perspective to the user rather than to finish a practical project. These guides should cover **why** things work they way they do.
-
-This guide on documentation style is meant to fall under this category.
-
-To quote the Diataxis website:
-
-> The perspective of explanation is higher and wider than that of the other types. It does not take the user’s eye-level view, as in a how-to guide, or a close-up view of the machinery, like reference material. Its scope in each case is a topic - “an area of knowledge”, that somehow has to be bounded in a reasonable, meaningful way.
-
-Some examples include:
-
-- [Retrieval conceptual docs](/docs/concepts/#retrieval)
-- [Chat model conceptual docs](/docs/concepts/#chat-models)
-
-Here are some high-level tips on writing a good conceptual guide:
-
-- Explain design decisions. Why does concept X exist and why was it designed this way?
-- Use analogies and reference other concepts and alternatives
-- Avoid blending in too much reference content
-- You can and should reference content covered in other guides, but make sure to link to them
-
-### References
-
-References contain detailed, low-level information that describes exactly what functionality exists and how to use it.
-In LangChain, this is mainly our API reference pages, which are populated from docstrings within code.
-References pages are generally not read end-to-end, but are consulted as necessary when a user needs to know
-how to use something specific.
-
-To quote the Diataxis website:
-
-> The only purpose of a reference guide is to describe, as succinctly as possible, and in an orderly way. Whereas the content of tutorials and how-to guides are led by needs of the user, reference material is led by the product it describes.
-
-Many of the reference pages in LangChain are automatically generated from code,
-but here are some high-level tips on writing a good docstring:
-
-- Be concise
-- Discuss special cases and deviations from a user's expectations
-- Go into detail on required inputs and outputs
-- Light details on when one might use the feature are fine, but in-depth details belong in other sections.
-
-Each category serves a distinct purpose and requires a specific approach to writing and structuring the content.
-
-## General guidelines
-
-Here are some other guidelines you should think about when writing and organizing documentation.
-
-We generally do not merge new tutorials from outside contributors without an actue need.
-We welcome updates as well as new integration docs, how-tos, and references.
-
-### Avoid duplication
-
-Multiple pages that cover the same material in depth are difficult to maintain and cause confusion. There should
-be only one (very rarely two), canonical pages for a given concept or feature. Instead, you should link to other guides.
-
-### Link 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!
-
-### Be concise
-
-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 fewer cells with more code to make copy/paste easier
-- 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

langchain_md_files/contributing/faq.mdx

@@ -1,26 +0,0 @@
----
-sidebar_position: 6
-sidebar_label: FAQ
----
-# Frequently Asked Questions
-
-## Pull Requests (PRs)
-
-### How do I allow maintainers to edit my PR?
-
-When you submit a pull request, there may be additional changes
-necessary before merging it. Oftentimes, it is more efficient for the
-maintainers to make these changes themselves before merging, rather than asking you
-to do so in code review.
-
-By default, most pull requests will have a 
-`✅ Maintainers are allowed to edit this pull request.`
-badge in the right-hand sidebar.
-
-If you do not see this badge, you may have this setting off for the fork you are
-pull-requesting from. See [this Github docs page](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/allowing-changes-to-a-pull-request-branch-created-from-a-fork)
-for more information.
-
-Notably, Github doesn't allow this setting to be enabled for forks in **organizations** ([issue](https://github.com/orgs/community/discussions/5634)).
-If you are working in an organization, we recommend submitting your PR from a personal
-fork in order to enable this setting.

langchain_md_files/contributing/index.mdx

@@ -1,54 +0,0 @@
----
-sidebar_position: 0
----
-# Welcome Contributors
-
-Hi there! Thank you for even being interested in contributing to LangChain.
-As an open-source project in a rapidly developing field, we are extremely open to contributions, whether they involve new features, improved infrastructure, better documentation, or bug fixes.
-
-## 🗺️ Guidelines
-
-### 👩‍💻 Ways to contribute
-
-There are many ways to contribute to LangChain. Here are some common ways people contribute:
-
-- [**Documentation**](/docs/contributing/documentation/): Help improve our docs, including this one!
-- [**Code**](/docs/contributing/code/): 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.
-
-### 🚩 GitHub Issues
-
-Our [issues](https://github.com/langchain-ai/langchain/issues) page is kept up to date with bugs, improvements, and feature requests.
-
-There is a taxonomy of labels to help with sorting and discovery of issues of interest. Please use these to help organize issues.
-
-If you start working on an issue, please assign it to yourself.
-
-If you are adding an issue, please try to keep it focused on a single, modular bug/improvement/feature.
-If two issues are related, or blocking, please link them rather than combining them.
-
-We will try to keep these issues as up-to-date as possible, though
-with the rapid rate of development in this field some may get out of date.
-If you notice this happening, please let us know.
-
-### 💭 GitHub Discussions
-
-We have a [discussions](https://github.com/langchain-ai/langchain/discussions) page where users can ask usage questions, discuss design decisions, and propose new features.
-
-If you are able to help answer questions, please do so! This will allow the maintainers to spend more time focused on development and bug fixing.
-
-### 🙋 Getting Help
-
-Our goal is to have the simplest developer setup possible. Should you experience any difficulty getting setup, please
-contact a maintainer! Not only do we want to help get you unblocked, but we also want to make sure that the process is
-smooth for future contributors.
-
-In a similar vein, we do enforce certain linting, formatting, and documentation standards in the codebase.
-If you are finding these difficult (or even just annoying) to work with, feel free to contact a maintainer for help -
-we do not want these to get in the way of getting good code into the codebase.
-
-### 🌟 Recognition
-
-If your contribution has made its way into a release, we will want to give you credit on Twitter (only if you want though)!
-If you have a Twitter account you would like us to mention, please let us know in the PR or through another means.

langchain_md_files/contributing/integrations.mdx

@@ -1,203 +0,0 @@
----
-sidebar_position: 5
----
-
-# Contribute Integrations
-
-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:
-
-- **Community**: For lighter-weight integrations that are primarily maintained by LangChain and the Open Source Community.
-- **Partner Packages**: For independent packages that are co-maintained by LangChain and a partner.
-
-For the most part, **new integrations should be added to the Community package**. Partner packages require more maintenance as separate packages, so please confirm with the LangChain team before creating a new partner package.
-
-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
-
-The `langchain-community` package is in `libs/community` and contains most integrations.
-
-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 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.
-
-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:
-
-```python
-from langchain_core.language_models.chat_models import BaseChatModel
-
-class ChatParrotLink(BaseChatModel):
-    """ChatParrotLink chat model.
-
-    Example:
-        .. code-block:: python
-
-            from langchain_community.chat_models import ChatParrotLink
-
-            model = ChatParrotLink()
-    """
-
-    ...
-```
-
-And we would write tests in:
-
-- Unit tests: `libs/community/tests/unit_tests/chat_models/test_parrot_link.py`
-- Integration tests: `libs/community/tests/integration_tests/chat_models/test_parrot_link.py`
-
-And add documentation to:
-
-- `docs/docs/integrations/chat/parrot_link.ipynb`
-
-## Partner package in LangChain repo
-
-:::caution
-Before starting a **partner** package, please confirm your intent with the LangChain team. Partner packages require more maintenance as separate packages, so we will close PRs that add new partner packages without prior discussion. See the above section for how to add a community integration.
-:::
-
-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
-```
-
-### Set up a new package
-
-To set up a new partner package, use the latest version of the LangChain CLI. You can install or update it with:
-
-```bash
-pip install -U langchain-cli
-```
-
-Let's say you want to create a new partner package working for a company called Parrot Link AI.
-
-Then, run the following command to create a new partner package:
-
-```bash
-cd libs/partners
-langchain-cli integration new
-> Name: parrot-link
-> Name of integration in PascalCase [ParrotLink]: ParrotLink
-```
-
-This will create a new package in `libs/partners/parrot-link` with the following structure:
-
-```
-libs/partners/parrot-link/
-  langchain_parrot_link/ # folder containing your package
-    ...
-  tests/
-    ...
-  docs/ # bootstrapped docs notebooks, must be moved to /docs in monorepo root
-    ...
-  scripts/ # scripts for CI
-    ...
-  LICENSE
-  README.md # fill out with information about your package
-  Makefile # default commands for CI
-  pyproject.toml # package metadata, mostly managed by Poetry
-  poetry.lock # package lockfile, managed by Poetry
-  .gitignore
-```
-
-### Implement your package
-
-First, add any dependencies your package needs, such as your company's SDK:
-
-```bash
-poetry add parrot-link-sdk
-```
-
-If you need separate dependencies for type checking, you can add them to the `typing` group with:
-
-```bash
-poetry add --group typing types-parrot-link-sdk
-```
-
-Then, implement your package in `libs/partners/parrot-link/langchain_parrot_link`.
-
-By default, this will include stubs for a Chat Model, an LLM, and/or a Vector Store. You should delete any of the files you won't use and remove them from `__init__.py`.
-
-### Write Unit and Integration Tests
-
-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](/docs/contributing/testing/).
-
-### Write documentation
-
-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
-
-Contributor steps:
-
-- [ ] Add secret names to manual integrations workflow in `.github/workflows/_integration_test.yml`
-- [ ] Add secrets to release workflow (for pre-release testing) in `.github/workflows/_release.yml`
-
-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.

langchain_md_files/contributing/repo_structure.mdx

@@ -1,65 +0,0 @@
----
-sidebar_position: 0.5
----
-# Repository Structure
-
-If you plan on contributing to LangChain code or documentation, it can be useful
-to understand the high level structure of the repository.
-
-LangChain is organized as a [monorepo](https://en.wikipedia.org/wiki/Monorepo) that contains multiple packages.
-You can check out our [installation guide](/docs/how_to/installation/) for more on how they fit together.
-
-Here's the structure visualized as a tree:
-
-```text
-.
-├── cookbook # Tutorials and examples
-├── docs # Contains content for the documentation here: https://python.langchain.com/
-├── libs
-│   ├── langchain
-│   │   ├── langchain
-│   │   ├── tests/unit_tests # Unit tests (present in each package not shown for brevity)
-│   │   ├── tests/integration_tests # Integration tests (present in each package not shown for brevity)
-│   ├── community # Third-party integrations
-│   │   ├── langchain-community
-│   ├── core # Base interfaces for key abstractions
-│   │   ├── langchain-core
-│   ├── experimental # Experimental components and chains
-│   │   ├── langchain-experimental
-|   ├── cli # Command line interface
-│   │   ├── langchain-cli
-│   ├── text-splitters
-│   │   ├── langchain-text-splitters
-│   ├── standard-tests
-│   │   ├── langchain-standard-tests
-│   ├── partners
-│       ├── langchain-partner-1
-│       ├── langchain-partner-2
-│       ├── ...
-│
-├── templates # A collection of easily deployable reference architectures for a wide variety of tasks.
-```
-
-The root directory also contains the following files:
-
-* `pyproject.toml`: Dependencies for building docs and linting docs, cookbook.
-* `Makefile`: A file that contains shortcuts for building, linting and docs and cookbook.
-
-There are other files in the root directory level, but their presence should be self-explanatory. Feel free to browse around!
-
-## Documentation
-
-The `/docs` directory contains the content for the documentation that is shown
-at https://python.langchain.com/ and the associated API Reference https://python.langchain.com/v0.2/api_reference/langchain/index.html.
-
-See the [documentation](/docs/contributing/documentation/) guidelines to learn how to contribute to the documentation.
-
-## Code
-
-The `/libs` directory contains the code for the LangChain packages.
-
-To learn more about how to contribute code see the following guidelines:
-
-- [Code](/docs/contributing/code/): Learn how to develop in the LangChain codebase.
-- [Integrations](./integrations.mdx): Learn how to contribute to third-party integrations to `langchain-community` or to start a new partner package.
-- [Testing](./testing.mdx): Guidelines to learn how to write tests for the packages.

langchain_md_files/contributing/testing.mdx

@@ -1,147 +0,0 @@
----
-sidebar_position: 6
----
-
-# Testing
-
-All of our packages have unit tests and integration tests, and we favor unit tests over integration tests.
-
-Unit tests run on every pull request, so they should be fast and reliable.
-
-Integration tests run once a day, and they require more setup, so they should be reserved for confirming interface points with external services.
-
-## Unit Tests
-
-Unit tests cover modular logic that does not require calls to outside APIs.
-If you add new logic, please add a unit test.
-
-To install dependencies for unit tests:
-
-```bash
-poetry install --with test
-```
-
-To run unit tests:
-
-```bash
-make test
-```
-
-To run unit tests in Docker:
-
-```bash
-make docker_tests
-```
-
-To run a specific test:
-
-```bash
-TEST_FILE=tests/unit_tests/test_imports.py make test
-```
-
-## Integration Tests
-
-Integration tests cover logic that requires making calls to outside APIs (often integration with other services).
-If you add support for a new external API, please add a new integration test.
-
-**Warning:** Almost no tests should be integration tests.
-
-  Tests that require making network connections make it difficult for other
-  developers to test the code.
-
-  Instead favor relying on `responses` library and/or mock.patch to mock
-  requests using small fixtures.
-
-To install dependencies for integration tests:
-
-```bash
-poetry install --with test,test_integration
-```
-
-To run integration tests:
-
-```bash
-make integration_tests
-```
-
-### Prepare
-
-The integration tests use several search engines and databases. The tests
-aim to verify the correct behavior of the engines and databases according to
-their specifications and requirements.
-
-To run some integration tests, such as tests located in
-`tests/integration_tests/vectorstores/`, you will need to install the following
-software:
-
-- Docker
-- Python 3.8.1 or later
-
-Any new dependencies should be added by running:
-
-```bash
-# add package and install it after adding:
-poetry add tiktoken@latest --group "test_integration" && poetry install --with test_integration
-```
-
-Before running any tests, you should start a specific Docker container that has all the
-necessary dependencies installed. For instance, we use the `elasticsearch.yml` container
-for `test_elasticsearch.py`:
-
-```bash
-cd tests/integration_tests/vectorstores/docker-compose
-docker-compose -f elasticsearch.yml up
-```
-
-For environments that requires more involving preparation, look for `*.sh`. For instance,
-`opensearch.sh` builds a required docker image and then launch opensearch.
-
-
-### Prepare environment variables for local testing:
-
-- copy `tests/integration_tests/.env.example` to `tests/integration_tests/.env`
-- set variables in `tests/integration_tests/.env` file, e.g `OPENAI_API_KEY`
-
-Additionally, it's important to note that some integration tests may require certain
-environment variables to be set, such as `OPENAI_API_KEY`. Be sure to set any required
-environment variables before running the tests to ensure they run correctly.
-
-### Recording HTTP interactions with pytest-vcr
-
-Some of the integration tests in this repository involve making HTTP requests to
-external services. To prevent these requests from being made every time the tests are
-run, we use pytest-vcr to record and replay HTTP interactions.
-
-When running tests in a CI/CD pipeline, you may not want to modify the existing
-cassettes. You can use the --vcr-record=none command-line option to disable recording
-new cassettes. Here's an example:
-
-```bash
-pytest --log-cli-level=10 tests/integration_tests/vectorstores/test_pinecone.py --vcr-record=none
-pytest tests/integration_tests/vectorstores/test_elasticsearch.py --vcr-record=none
-
-```
-
-### Run some tests with coverage:
-
-```bash
-pytest tests/integration_tests/vectorstores/test_elasticsearch.py --cov=langchain --cov-report=html
-start "" htmlcov/index.html || open htmlcov/index.html
-
-```
-
-## Coverage
-
-Code coverage (i.e. the amount of code that is covered by unit tests) helps identify areas of the code that are potentially more or less brittle.
-
-Coverage requires the dependencies for integration tests:
-
-```bash
-poetry install --with test_integration
-```
-
-To get a report of current coverage, run the following:
-
-```bash
-make coverage
-```

langchain_md_files/how_to/document_loader_json.mdx

@@ -1,402 +0,0 @@
-# How to load JSON
-
-[JSON (JavaScript Object Notation)](https://en.wikipedia.org/wiki/JSON) is an open standard file format and data interchange format that uses human-readable text to store and transmit data objects consisting of attribute–value pairs and arrays (or other serializable values).
-
-[JSON Lines](https://jsonlines.org/) is a file format where each line is a valid JSON value.
-
-LangChain implements a [JSONLoader](https://python.langchain.com/v0.2/api_reference/community/document_loaders/langchain_community.document_loaders.json_loader.JSONLoader.html) 
-to convert JSON and JSONL data into LangChain [Document](https://python.langchain.com/v0.2/api_reference/core/documents/langchain_core.documents.base.Document.html#langchain_core.documents.base.Document) 
-objects. It uses a specified [jq schema](https://en.wikipedia.org/wiki/Jq_(programming_language)) to parse the JSON files, allowing for the extraction of specific fields into the content 
-and metadata of the LangChain Document.
-
-It uses the `jq` python package. Check out this [manual](https://stedolan.github.io/jq/manual/#Basicfilters) for a detailed documentation of the `jq` syntax.
-
-Here we will demonstrate: 
-
-- How to load JSON and JSONL data into the content of a LangChain `Document`;
-- How to load JSON and JSONL data into metadata associated with a `Document`.
-
-
-```python
-#!pip install jq
-```
-
-
-```python
-from langchain_community.document_loaders import JSONLoader
-```
-
-
-```python
-import json
-from pathlib import Path
-from pprint import pprint
-
-
-file_path='./example_data/facebook_chat.json'
-data = json.loads(Path(file_path).read_text())
-```
-
-
-```python
-pprint(data)
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    {'image': {'creation_timestamp': 1675549016, 'uri': 'image_of_the_chat.jpg'},
-     'is_still_participant': True,
-     'joinable_mode': {'link': '', 'mode': 1},
-     'magic_words': [],
-     'messages': [{'content': 'Bye!',
-                   'sender_name': 'User 2',
-                   'timestamp_ms': 1675597571851},
-                  {'content': 'Oh no worries! Bye',
-                   'sender_name': 'User 1',
-                   'timestamp_ms': 1675597435669},
-                  {'content': 'No Im sorry it was my mistake, the blue one is not '
-                              'for sale',
-                   'sender_name': 'User 2',
-                   'timestamp_ms': 1675596277579},
-                  {'content': 'I thought you were selling the blue one!',
-                   'sender_name': 'User 1',
-                   'timestamp_ms': 1675595140251},
-                  {'content': 'Im not interested in this bag. Im interested in the '
-                              'blue one!',
-                   'sender_name': 'User 1',
-                   'timestamp_ms': 1675595109305},
-                  {'content': 'Here is $129',
-                   'sender_name': 'User 2',
-                   'timestamp_ms': 1675595068468},
-                  {'photos': [{'creation_timestamp': 1675595059,
-                               'uri': 'url_of_some_picture.jpg'}],
-                   'sender_name': 'User 2',
-                   'timestamp_ms': 1675595060730},
-                  {'content': 'Online is at least $100',
-                   'sender_name': 'User 2',
-                   'timestamp_ms': 1675595045152},
-                  {'content': 'How much do you want?',
-                   'sender_name': 'User 1',
-                   'timestamp_ms': 1675594799696},
-                  {'content': 'Goodmorning! $50 is too low.',
-                   'sender_name': 'User 2',
-                   'timestamp_ms': 1675577876645},
-                  {'content': 'Hi! Im interested in your bag. Im offering $50. Let '
-                              'me know if you are interested. Thanks!',
-                   'sender_name': 'User 1',
-                   'timestamp_ms': 1675549022673}],
-     'participants': [{'name': 'User 1'}, {'name': 'User 2'}],
-     'thread_path': 'inbox/User 1 and User 2 chat',
-     'title': 'User 1 and User 2 chat'}
-```
-
-</CodeOutputBlock>
-
-
-## Using `JSONLoader`
-
-Suppose we are interested in extracting the values under the `content` field within the `messages` key of the JSON data. This can easily be done through the `JSONLoader` as shown below.
-
-
-### JSON file
-
-```python
-loader = JSONLoader(
-    file_path='./example_data/facebook_chat.json',
-    jq_schema='.messages[].content',
-    text_content=False)
-
-data = loader.load()
-```
-
-
-```python
-pprint(data)
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    [Document(page_content='Bye!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 1}),
-     Document(page_content='Oh no worries! Bye', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 2}),
-     Document(page_content='No Im sorry it was my mistake, the blue one is not for sale', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 3}),
-     Document(page_content='I thought you were selling the blue one!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 4}),
-     Document(page_content='Im not interested in this bag. Im interested in the blue one!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 5}),
-     Document(page_content='Here is $129', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 6}),
-     Document(page_content='', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 7}),
-     Document(page_content='Online is at least $100', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 8}),
-     Document(page_content='How much do you want?', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 9}),
-     Document(page_content='Goodmorning! $50 is too low.', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 10}),
-     Document(page_content='Hi! Im interested in your bag. Im offering $50. Let me know if you are interested. Thanks!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 11})]
-```
-
-</CodeOutputBlock>
-
-
-### JSON Lines file
-
-If you want to load documents from a JSON Lines file, you pass `json_lines=True`
-and specify `jq_schema` to extract `page_content` from a single JSON object.
-
-```python
-file_path = './example_data/facebook_chat_messages.jsonl'
-pprint(Path(file_path).read_text())
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    ('{"sender_name": "User 2", "timestamp_ms": 1675597571851, "content": "Bye!"}\n'
-     '{"sender_name": "User 1", "timestamp_ms": 1675597435669, "content": "Oh no '
-     'worries! Bye"}\n'
-     '{"sender_name": "User 2", "timestamp_ms": 1675596277579, "content": "No Im '
-     'sorry it was my mistake, the blue one is not for sale"}\n')
-```
-
-</CodeOutputBlock>
-
-
-```python
-loader = JSONLoader(
-    file_path='./example_data/facebook_chat_messages.jsonl',
-    jq_schema='.content',
-    text_content=False,
-    json_lines=True)
-
-data = loader.load()
-```
-
-```python
-pprint(data)
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    [Document(page_content='Bye!', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat_messages.jsonl', 'seq_num': 1}),
-     Document(page_content='Oh no worries! Bye', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat_messages.jsonl', 'seq_num': 2}),
-     Document(page_content='No Im sorry it was my mistake, the blue one is not for sale', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat_messages.jsonl', 'seq_num': 3})]
-```
-
-</CodeOutputBlock>
-
-
-Another option is to set `jq_schema='.'` and provide `content_key`:
-
-```python
-loader = JSONLoader(
-    file_path='./example_data/facebook_chat_messages.jsonl',
-    jq_schema='.',
-    content_key='sender_name',
-    json_lines=True)
-
-data = loader.load()
-```
-
-```python
-pprint(data)
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    [Document(page_content='User 2', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat_messages.jsonl', 'seq_num': 1}),
-     Document(page_content='User 1', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat_messages.jsonl', 'seq_num': 2}),
-     Document(page_content='User 2', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat_messages.jsonl', 'seq_num': 3})]
-```
-
-</CodeOutputBlock>
-
-### JSON file with jq schema `content_key`
-
-To load documents from a JSON file using the content_key within the jq schema, set is_content_key_jq_parsable=True. 
-Ensure that content_key is compatible and can be parsed using the jq schema.
-
-```python
-file_path = './sample.json'
-pprint(Path(file_path).read_text())
-```
-
-<CodeOutputBlock lang="python">
-
-```json
-    {"data": [
-        {"attributes": {
-            "message": "message1",
-            "tags": [
-            "tag1"]},
-        "id": "1"},
-        {"attributes": {
-            "message": "message2",
-            "tags": [
-            "tag2"]},
-        "id": "2"}]}
-```
-
-</CodeOutputBlock>
-
-
-```python
-loader = JSONLoader(
-    file_path=file_path,
-    jq_schema=".data[]",
-    content_key=".attributes.message",
-    is_content_key_jq_parsable=True,
-)
-
-data = loader.load()
-```
-
-```python
-pprint(data)
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    [Document(page_content='message1', metadata={'source': '/path/to/sample.json', 'seq_num': 1}),
-     Document(page_content='message2', metadata={'source': '/path/to/sample.json', 'seq_num': 2})]
-```
-
-</CodeOutputBlock>
-
-## Extracting metadata
-
-Generally, we want to include metadata available in the JSON file into the documents that we create from the content.
-
-The following demonstrates how metadata can be extracted using the `JSONLoader`.
-
-There are some key changes to be noted. In the previous example where we didn't collect the metadata, we managed to directly specify in the schema where the value for the `page_content` can be extracted from.
-
-```
-.messages[].content
-```
-
-In the current example, we have to tell the loader to iterate over the records in the `messages` field. The jq_schema then has to be:
-
-```
-.messages[]
-```
-
-This allows us to pass the records (dict) into the `metadata_func` that has to be implemented. The `metadata_func` is responsible for identifying which pieces of information in the record should be included in the metadata stored in the final `Document` object.
-
-Additionally, we now have to explicitly specify in the loader, via the `content_key` argument, the key from the record where the value for the `page_content` needs to be extracted from.
-
-
-```python
-# Define the metadata extraction function.
-def metadata_func(record: dict, metadata: dict) -> dict:
-
-    metadata["sender_name"] = record.get("sender_name")
-    metadata["timestamp_ms"] = record.get("timestamp_ms")
-
-    return metadata
-
-
-loader = JSONLoader(
-    file_path='./example_data/facebook_chat.json',
-    jq_schema='.messages[]',
-    content_key="content",
-    metadata_func=metadata_func
-)
-
-data = loader.load()
-```
-
-
-```python
-pprint(data)
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    [Document(page_content='Bye!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 1, 'sender_name': 'User 2', 'timestamp_ms': 1675597571851}),
-     Document(page_content='Oh no worries! Bye', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 2, 'sender_name': 'User 1', 'timestamp_ms': 1675597435669}),
-     Document(page_content='No Im sorry it was my mistake, the blue one is not for sale', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 3, 'sender_name': 'User 2', 'timestamp_ms': 1675596277579}),
-     Document(page_content='I thought you were selling the blue one!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 4, 'sender_name': 'User 1', 'timestamp_ms': 1675595140251}),
-     Document(page_content='Im not interested in this bag. Im interested in the blue one!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 5, 'sender_name': 'User 1', 'timestamp_ms': 1675595109305}),
-     Document(page_content='Here is $129', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 6, 'sender_name': 'User 2', 'timestamp_ms': 1675595068468}),
-     Document(page_content='', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 7, 'sender_name': 'User 2', 'timestamp_ms': 1675595060730}),
-     Document(page_content='Online is at least $100', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 8, 'sender_name': 'User 2', 'timestamp_ms': 1675595045152}),
-     Document(page_content='How much do you want?', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 9, 'sender_name': 'User 1', 'timestamp_ms': 1675594799696}),
-     Document(page_content='Goodmorning! $50 is too low.', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 10, 'sender_name': 'User 2', 'timestamp_ms': 1675577876645}),
-     Document(page_content='Hi! Im interested in your bag. Im offering $50. Let me know if you are interested. Thanks!', metadata={'source': '/Users/avsolatorio/WBG/langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 11, 'sender_name': 'User 1', 'timestamp_ms': 1675549022673})]
-```
-
-</CodeOutputBlock>
-
-Now, you will see that the documents contain the metadata associated with the content we extracted.
-
-## The `metadata_func`
-
-As shown above, the `metadata_func` accepts the default metadata generated by the `JSONLoader`. This allows full control to the user with respect to how the metadata is formatted.
-
-For example, the default metadata contains the `source` and the `seq_num` keys. However, it is possible that the JSON data contain these keys as well. The user can then exploit the `metadata_func` to rename the default keys and use the ones from the JSON data.
-
-The example below shows how we can modify the `source` to only contain information of the file source relative to the `langchain` directory.
-
-
-```python
-# Define the metadata extraction function.
-def metadata_func(record: dict, metadata: dict) -> dict:
-
-    metadata["sender_name"] = record.get("sender_name")
-    metadata["timestamp_ms"] = record.get("timestamp_ms")
-
-    if "source" in metadata:
-        source = metadata["source"].split("/")
-        source = source[source.index("langchain"):]
-        metadata["source"] = "/".join(source)
-
-    return metadata
-
-
-loader = JSONLoader(
-    file_path='./example_data/facebook_chat.json',
-    jq_schema='.messages[]',
-    content_key="content",
-    metadata_func=metadata_func
-)
-
-data = loader.load()
-```
-
-
-```python
-pprint(data)
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    [Document(page_content='Bye!', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 1, 'sender_name': 'User 2', 'timestamp_ms': 1675597571851}),
-     Document(page_content='Oh no worries! Bye', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 2, 'sender_name': 'User 1', 'timestamp_ms': 1675597435669}),
-     Document(page_content='No Im sorry it was my mistake, the blue one is not for sale', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 3, 'sender_name': 'User 2', 'timestamp_ms': 1675596277579}),
-     Document(page_content='I thought you were selling the blue one!', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 4, 'sender_name': 'User 1', 'timestamp_ms': 1675595140251}),
-     Document(page_content='Im not interested in this bag. Im interested in the blue one!', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 5, 'sender_name': 'User 1', 'timestamp_ms': 1675595109305}),
-     Document(page_content='Here is $129', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 6, 'sender_name': 'User 2', 'timestamp_ms': 1675595068468}),
-     Document(page_content='', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 7, 'sender_name': 'User 2', 'timestamp_ms': 1675595060730}),
-     Document(page_content='Online is at least $100', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 8, 'sender_name': 'User 2', 'timestamp_ms': 1675595045152}),
-     Document(page_content='How much do you want?', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 9, 'sender_name': 'User 1', 'timestamp_ms': 1675594799696}),
-     Document(page_content='Goodmorning! $50 is too low.', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 10, 'sender_name': 'User 2', 'timestamp_ms': 1675577876645}),
-     Document(page_content='Hi! Im interested in your bag. Im offering $50. Let me know if you are interested. Thanks!', metadata={'source': 'langchain/docs/modules/indexes/document_loaders/examples/example_data/facebook_chat.json', 'seq_num': 11, 'sender_name': 'User 1', 'timestamp_ms': 1675549022673})]
-```
-
-</CodeOutputBlock>
-
-## Common JSON structures with jq schema
-
-The list below provides a reference to the possible `jq_schema` the user can use to extract content from the JSON data depending on the structure.
-
-```
-JSON        -> [{"text": ...}, {"text": ...}, {"text": ...}]
-jq_schema   -> ".[].text"
-
-JSON        -> {"key": [{"text": ...}, {"text": ...}, {"text": ...}]}
-jq_schema   -> ".key[].text"
-
-JSON        -> ["...", "...", "..."]
-jq_schema   -> ".[]"
-```

langchain_md_files/how_to/document_loader_office_file.mdx

@@ -1,35 +0,0 @@
-# How to load Microsoft Office files
-
-The [Microsoft Office](https://www.office.com/) suite of productivity software includes Microsoft Word, Microsoft Excel, Microsoft PowerPoint, Microsoft Outlook, and Microsoft OneNote. It is available for Microsoft Windows and macOS operating systems. It is also available on Android and iOS.
-
-This covers how to load commonly used file formats including `DOCX`, `XLSX` and `PPTX` documents into a LangChain 
-[Document](https://python.langchain.com/v0.2/api_reference/core/documents/langchain_core.documents.base.Document.html#langchain_core.documents.base.Document)
-object that we can use downstream.
-
-
-## Loading DOCX, XLSX, PPTX with AzureAIDocumentIntelligenceLoader
-
-[Azure AI Document Intelligence](https://aka.ms/doc-intelligence) (formerly known as `Azure Form Recognizer`) is machine-learning 
-based service that extracts texts (including handwriting), tables, document structures (e.g., titles, section headings, etc.) and key-value-pairs from
-digital or scanned PDFs, images, Office and HTML files. Document Intelligence supports `PDF`, `JPEG/JPG`, `PNG`, `BMP`, `TIFF`, `HEIF`, `DOCX`, `XLSX`, `PPTX` and `HTML`.
-
-This [current implementation](https://aka.ms/di-langchain) of a loader using `Document Intelligence` can incorporate content page-wise and turn it into LangChain documents. The default output format is markdown, which can be easily chained with `MarkdownHeaderTextSplitter` for semantic document chunking. You can also use `mode="single"` or `mode="page"` to return pure texts in a single page or document split by page.
-
-### Prerequisite
-
-An Azure AI Document Intelligence resource in one of the 3 preview regions: **East US**, **West US2**, **West Europe** - follow [this document](https://learn.microsoft.com/azure/ai-services/document-intelligence/create-document-intelligence-resource?view=doc-intel-4.0.0) to create one if you don't have. You will be passing `<endpoint>` and `<key>` as parameters to the loader.
-
-```python
-%pip install --upgrade --quiet  langchain langchain-community azure-ai-documentintelligence
-
-from langchain_community.document_loaders import AzureAIDocumentIntelligenceLoader
-
-file_path = "<filepath>"
-endpoint = "<endpoint>"
-key = "<key>"
-loader = AzureAIDocumentIntelligenceLoader(
-    api_endpoint=endpoint, api_key=key, file_path=file_path, api_model="prebuilt-layout"
-)
-
-documents = loader.load()
-```

langchain_md_files/how_to/embed_text.mdx

@@ -1,154 +0,0 @@
-# Text embedding models
-
-:::info
-Head to [Integrations](/docs/integrations/text_embedding/) for documentation on built-in integrations with text embedding model providers.
-:::
-
-The Embeddings class is a class designed for interfacing with text embedding models. There are lots of embedding model providers (OpenAI, Cohere, Hugging Face, etc) - this class is designed to provide a standard interface for all of them.
-
-Embeddings create a vector representation of a piece of text. This is useful because it means we can think about text in the vector space, and do things like semantic search where we look for pieces of text that are most similar in the vector space.
-
-The base Embeddings class in LangChain provides two methods: one for embedding documents and one for embedding a query. The former, `.embed_documents`, takes as input multiple texts, while the latter, `.embed_query`, takes a single text. The reason for having these as two separate methods is that some embedding providers have different embedding methods for documents (to be searched over) vs queries (the search query itself). 
-`.embed_query` will return a list of floats, whereas `.embed_documents` returns a list of lists of floats.
-
-## Get started
-
-### Setup
-
-import Tabs from '@theme/Tabs';
-import TabItem from '@theme/TabItem';
-
-<Tabs>
-  <TabItem value="openai" label="OpenAI" default>
-To start we'll need to install the OpenAI partner package:
-
-```bash
-pip install langchain-openai
-```
-
-Accessing the API requires an API key, which you can get by creating an account and heading [here](https://platform.openai.com/account/api-keys). Once we have a key we'll want to set it as an environment variable by running:
-
-```bash
-export OPENAI_API_KEY="..."
-```
-
-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 OpenAIEmbeddings
-
-embeddings_model = OpenAIEmbeddings(api_key="...")
-```
-
-Otherwise you can initialize without any params:
-```python
-from langchain_openai import OpenAIEmbeddings
-
-embeddings_model = OpenAIEmbeddings()
-```
-
-  </TabItem>
-  <TabItem value="cohere" label="Cohere">
-
-To start we'll need to install the Cohere SDK package:
-
-```bash
-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:
-
-```shell
-export COHERE_API_KEY="..."
-```
-
-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_cohere import CohereEmbeddings
-
-embeddings_model = CohereEmbeddings(cohere_api_key="...", model='embed-english-v3.0')
-```
-
-Otherwise you can initialize simply as shown below:
-```python
-from langchain_cohere import CohereEmbeddings
-
-embeddings_model = CohereEmbeddings(model='embed-english-v3.0')
-```
-Do note that it is mandatory to pass the model parameter while initializing the CohereEmbeddings class.
-
-  </TabItem>
-  <TabItem value="huggingface" label="Hugging Face">
-
-To start we'll need to install the Hugging Face partner package:
-
-```bash
-pip install langchain-huggingface
-```
-
-You can then load any [Sentence Transformers model](https://huggingface.co/models?library=sentence-transformers) from the Hugging Face Hub.
-
-```python
-from langchain_huggingface import HuggingFaceEmbeddings
-
-embeddings_model = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")
-```
-
-You can also leave the `model_name` blank to use the default [sentence-transformers/all-mpnet-base-v2](https://huggingface.co/sentence-transformers/all-mpnet-base-v2) model.
-
-```python
-from langchain_huggingface import HuggingFaceEmbeddings
-
-embeddings_model = HuggingFaceEmbeddings()
-```
-
-  </TabItem>
-</Tabs>
-
-### `embed_documents`
-#### Embed list of texts
-
-Use `.embed_documents` to embed a list of strings, recovering a list of embeddings:
-
-```python
-embeddings = embeddings_model.embed_documents(
-    [
-        "Hi there!",
-        "Oh, hello!",
-        "What's your name?",
-        "My friends call me World",
-        "Hello World!"
-    ]
-)
-len(embeddings), len(embeddings[0])
-```
-
-<CodeOutputBlock language="python">
-
-```
-(5, 1536)
-```
-
-</CodeOutputBlock>
-
-### `embed_query`
-#### Embed single query
-Use `.embed_query` to embed a single piece of text (e.g., for the purpose of comparing to other embedded pieces of texts).
-
-```python
-embedded_query = embeddings_model.embed_query("What was the name mentioned in the conversation?")
-embedded_query[:5]
-```
-
-<CodeOutputBlock language="python">
-
-```
-[0.0053587136790156364,
- -0.0004999046213924885,
- 0.038883671164512634,
- -0.003001077566295862,
- -0.00900818221271038]
-```
-
-</CodeOutputBlock>

langchain_md_files/how_to/index.mdx

@@ -1,361 +0,0 @@
----
-sidebar_position: 0
-sidebar_class_name: hidden
----
-
-# How-to guides
-
-Here you’ll find answers to “How do I….?” types of questions.
-These guides are *goal-oriented* and *concrete*; they're meant to help you complete a specific task.
-For conceptual explanations see the [Conceptual guide](/docs/concepts/).
-For end-to-end walkthroughs see [Tutorials](/docs/tutorials).
-For comprehensive descriptions of every class and function see the [API Reference](https://python.langchain.com/v0.2/api_reference/).
-
-## Installation
-
-- [How to: install LangChain packages](/docs/how_to/installation/)
-- [How to: use LangChain with different Pydantic versions](/docs/how_to/pydantic_compatibility)
-
-## Key features
-
-This highlights functionality that is core to using LangChain.
-
-- [How to: return structured data from a model](/docs/how_to/structured_output/)
-- [How to: use a model to call tools](/docs/how_to/tool_calling)
-- [How to: stream runnables](/docs/how_to/streaming)
-- [How to: debug your LLM apps](/docs/how_to/debugging/)
-
-## LangChain Expression Language (LCEL)
-
-[LangChain Expression Language](/docs/concepts/#langchain-expression-language-lcel) is a way to create arbitrary custom chains. It is built on the [Runnable](https://python.langchain.com/v0.2/api_reference/core/runnables/langchain_core.runnables.base.Runnable.html) protocol.
-
-[**LCEL cheatsheet**](/docs/how_to/lcel_cheatsheet/): For a quick overview of how to use the main LCEL primitives.
-
-[**Migration guide**](/docs/versions/migrating_chains): For migrating legacy chain abstractions to LCEL.
-
-- [How to: chain runnables](/docs/how_to/sequence)
-- [How to: stream runnables](/docs/how_to/streaming)
-- [How to: invoke runnables in parallel](/docs/how_to/parallel/)
-- [How to: add default invocation args to runnables](/docs/how_to/binding/)
-- [How to: turn any function into a runnable](/docs/how_to/functions)
-- [How to: pass through inputs from one chain step to the next](/docs/how_to/passthrough)
-- [How to: configure runnable behavior at runtime](/docs/how_to/configure)
-- [How to: add message history (memory) to a chain](/docs/how_to/message_history)
-- [How to: route between sub-chains](/docs/how_to/routing)
-- [How to: create a dynamic (self-constructing) chain](/docs/how_to/dynamic_chain/)
-- [How to: inspect runnables](/docs/how_to/inspect)
-- [How to: add fallbacks to a runnable](/docs/how_to/fallbacks)
-- [How to: pass runtime secrets to a runnable](/docs/how_to/runnable_runtime_secrets)
-
-## Components
-
-These are the core building blocks you can use when building applications.
-
-### Prompt templates
-
-[Prompt Templates](/docs/concepts/#prompt-templates) are responsible for formatting user input into a format that can be passed to a language model.
-
-- [How to: use few shot examples](/docs/how_to/few_shot_examples)
-- [How to: use few shot examples in chat models](/docs/how_to/few_shot_examples_chat/)
-- [How to: partially format prompt templates](/docs/how_to/prompts_partial)
-- [How to: compose prompts together](/docs/how_to/prompts_composition)
-
-### Example selectors
-
-[Example Selectors](/docs/concepts/#example-selectors) are responsible for selecting the correct few shot examples to pass to the prompt.
-
-- [How to: use example selectors](/docs/how_to/example_selectors)
-- [How to: select examples by length](/docs/how_to/example_selectors_length_based)
-- [How to: select examples by semantic similarity](/docs/how_to/example_selectors_similarity)
-- [How to: select examples by semantic ngram overlap](/docs/how_to/example_selectors_ngram)
-- [How to: select examples by maximal marginal relevance](/docs/how_to/example_selectors_mmr)
-- [How to: select examples from LangSmith few-shot datasets](/docs/how_to/example_selectors_langsmith/)
-
-### Chat models
-
-[Chat Models](/docs/concepts/#chat-models) are newer forms of language models that take messages in and output a message.
-
-- [How to: do function/tool calling](/docs/how_to/tool_calling)
-- [How to: get models to return structured output](/docs/how_to/structured_output)
-- [How to: cache model responses](/docs/how_to/chat_model_caching)
-- [How to: get log probabilities](/docs/how_to/logprobs)
-- [How to: create a custom chat model class](/docs/how_to/custom_chat_model)
-- [How to: stream a response back](/docs/how_to/chat_streaming)
-- [How to: track token usage](/docs/how_to/chat_token_usage_tracking)
-- [How to: track response metadata across providers](/docs/how_to/response_metadata)
-- [How to: use chat model to call tools](/docs/how_to/tool_calling)
-- [How to: stream tool calls](/docs/how_to/tool_streaming)
-- [How to: handle rate limits](/docs/how_to/chat_model_rate_limiting)
-- [How to: few shot prompt tool behavior](/docs/how_to/tools_few_shot)
-- [How to: bind model-specific formatted tools](/docs/how_to/tools_model_specific)
-- [How to: force a specific tool call](/docs/how_to/tool_choice)
-- [How to: work with local models](/docs/how_to/local_llms)
-- [How to: init any model in one line](/docs/how_to/chat_models_universal_init/)
-
-### Messages
-
-[Messages](/docs/concepts/#messages) are the input and output of chat models. They have some `content` and a `role`, which describes the source of the message.
-
-- [How to: trim messages](/docs/how_to/trim_messages/)
-- [How to: filter messages](/docs/how_to/filter_messages/)
-- [How to: merge consecutive messages of the same type](/docs/how_to/merge_message_runs/)
-
-### LLMs
-
-What LangChain calls [LLMs](/docs/concepts/#llms) are older forms of language models that take a string in and output a string.
-
-- [How to: cache model responses](/docs/how_to/llm_caching)
-- [How to: create a custom LLM class](/docs/how_to/custom_llm)
-- [How to: stream a response back](/docs/how_to/streaming_llm)
-- [How to: track token usage](/docs/how_to/llm_token_usage_tracking)
-- [How to: work with local models](/docs/how_to/local_llms)
-
-### Output parsers
-
-[Output Parsers](/docs/concepts/#output-parsers) are responsible for taking the output of an LLM and parsing into more structured format.
-
-- [How to: use output parsers to parse an LLM response into structured format](/docs/how_to/output_parser_structured)
-- [How to: parse JSON output](/docs/how_to/output_parser_json)
-- [How to: parse XML output](/docs/how_to/output_parser_xml)
-- [How to: parse YAML output](/docs/how_to/output_parser_yaml)
-- [How to: retry when output parsing errors occur](/docs/how_to/output_parser_retry)
-- [How to: try to fix errors in output parsing](/docs/how_to/output_parser_fixing)
-- [How to: write a custom output parser class](/docs/how_to/output_parser_custom)
-
-### Document loaders
-
-[Document Loaders](/docs/concepts/#document-loaders) are responsible for loading documents from a variety of sources.
-
-- [How to: load CSV data](/docs/how_to/document_loader_csv)
-- [How to: load data from a directory](/docs/how_to/document_loader_directory)
-- [How to: load HTML data](/docs/how_to/document_loader_html)
-- [How to: load JSON data](/docs/how_to/document_loader_json)
-- [How to: load Markdown data](/docs/how_to/document_loader_markdown)
-- [How to: load Microsoft Office data](/docs/how_to/document_loader_office_file)
-- [How to: load PDF files](/docs/how_to/document_loader_pdf)
-- [How to: write a custom document loader](/docs/how_to/document_loader_custom)
-
-### Text splitters
-
-[Text Splitters](/docs/concepts/#text-splitters) take a document and split into chunks that can be used for retrieval.
-
-- [How to: recursively split text](/docs/how_to/recursive_text_splitter)
-- [How to: split by HTML headers](/docs/how_to/HTML_header_metadata_splitter)
-- [How to: split by HTML sections](/docs/how_to/HTML_section_aware_splitter)
-- [How to: split by character](/docs/how_to/character_text_splitter)
-- [How to: split code](/docs/how_to/code_splitter)
-- [How to: split Markdown by headers](/docs/how_to/markdown_header_metadata_splitter)
-- [How to: recursively split JSON](/docs/how_to/recursive_json_splitter)
-- [How to: split text into semantic chunks](/docs/how_to/semantic-chunker)
-- [How to: split by tokens](/docs/how_to/split_by_token)
-
-### Embedding models
-
-[Embedding Models](/docs/concepts/#embedding-models) take a piece of text and create a numerical representation of it.
-
-- [How to: embed text data](/docs/how_to/embed_text)
-- [How to: cache embedding results](/docs/how_to/caching_embeddings)
-
-### Vector stores
-
-[Vector stores](/docs/concepts/#vector-stores) are databases that can efficiently store and retrieve embeddings.
-
-- [How to: use a vector store to retrieve data](/docs/how_to/vectorstores)
-
-### Retrievers
-
-[Retrievers](/docs/concepts/#retrievers) are responsible for taking a query and returning relevant documents.
-
-- [How to: use a vector store to retrieve data](/docs/how_to/vectorstore_retriever)
-- [How to: generate multiple queries to retrieve data for](/docs/how_to/MultiQueryRetriever)
-- [How to: use contextual compression to compress the data retrieved](/docs/how_to/contextual_compression)
-- [How to: write a custom retriever class](/docs/how_to/custom_retriever)
-- [How to: add similarity scores to retriever results](/docs/how_to/add_scores_retriever)
-- [How to: combine the results from multiple retrievers](/docs/how_to/ensemble_retriever)
-- [How to: reorder retrieved results to mitigate the "lost in the middle" effect](/docs/how_to/long_context_reorder)
-- [How to: generate multiple embeddings per document](/docs/how_to/multi_vector)
-- [How to: retrieve the whole document for a chunk](/docs/how_to/parent_document_retriever)
-- [How to: generate metadata filters](/docs/how_to/self_query)
-- [How to: create a time-weighted retriever](/docs/how_to/time_weighted_vectorstore)
-- [How to: use hybrid vector and keyword retrieval](/docs/how_to/hybrid)
-
-### Indexing
-
-Indexing is the process of keeping your vectorstore in-sync with the underlying data source.
-
-- [How to: reindex data to keep your vectorstore in-sync with the underlying data source](/docs/how_to/indexing)
-
-### Tools
-
-LangChain [Tools](/docs/concepts/#tools) contain a description of the tool (to pass to the language model) as well as the implementation of the function to call. Refer [here](/docs/integrations/tools/) for a list of pre-buit tools. 
-
-- [How to: create tools](/docs/how_to/custom_tools)
-- [How to: use built-in tools and toolkits](/docs/how_to/tools_builtin)
-- [How to: use chat models to call tools](/docs/how_to/tool_calling)
-- [How to: pass tool outputs to chat models](/docs/how_to/tool_results_pass_to_model)
-- [How to: pass run time values to tools](/docs/how_to/tool_runtime)
-- [How to: add a human-in-the-loop for tools](/docs/how_to/tools_human)
-- [How to: handle tool errors](/docs/how_to/tools_error)
-- [How to: force models to call a tool](/docs/how_to/tool_choice)
-- [How to: disable parallel tool calling](/docs/how_to/tool_calling_parallel)
-- [How to: access the `RunnableConfig` from a tool](/docs/how_to/tool_configure)
-- [How to: stream events from a tool](/docs/how_to/tool_stream_events)
-- [How to: return artifacts from a tool](/docs/how_to/tool_artifacts/)
-- [How to: convert Runnables to tools](/docs/how_to/convert_runnable_to_tool)
-- [How to: add ad-hoc tool calling capability to models](/docs/how_to/tools_prompting)
-- [How to: pass in runtime secrets](/docs/how_to/runnable_runtime_secrets)
-
-### Multimodal
-
-- [How to: pass multimodal data directly to models](/docs/how_to/multimodal_inputs/)
-- [How to: use multimodal prompts](/docs/how_to/multimodal_prompts/)
-
-
-### Agents
-
-:::note
-
-For in depth how-to guides for agents, please check out [LangGraph](https://langchain-ai.github.io/langgraph/) documentation.
-
-:::
-
-- [How to: use legacy LangChain Agents (AgentExecutor)](/docs/how_to/agent_executor)
-- [How to: migrate from legacy LangChain agents to LangGraph](/docs/how_to/migrate_agent)
-
-### Callbacks
-
-[Callbacks](/docs/concepts/#callbacks) allow you to hook into the various stages of your LLM application's execution.
-
-- [How to: pass in callbacks at runtime](/docs/how_to/callbacks_runtime)
-- [How to: attach callbacks to a module](/docs/how_to/callbacks_attach)
-- [How to: pass callbacks into a module constructor](/docs/how_to/callbacks_constructor)
-- [How to: create custom callback handlers](/docs/how_to/custom_callbacks)
-- [How to: use callbacks in async environments](/docs/how_to/callbacks_async)
-- [How to: dispatch custom callback events](/docs/how_to/callbacks_custom_events)
-
-### Custom
-
-All of LangChain components can easily be extended to support your own versions.
-
-- [How to: create a custom chat model class](/docs/how_to/custom_chat_model)
-- [How to: create a custom LLM class](/docs/how_to/custom_llm)
-- [How to: write a custom retriever class](/docs/how_to/custom_retriever)
-- [How to: write a custom document loader](/docs/how_to/document_loader_custom)
-- [How to: write a custom output parser class](/docs/how_to/output_parser_custom)
-- [How to: create custom callback handlers](/docs/how_to/custom_callbacks)
-- [How to: define a custom tool](/docs/how_to/custom_tools)
-- [How to: dispatch custom callback events](/docs/how_to/callbacks_custom_events)
-
-### Serialization
-- [How to: save and load LangChain objects](/docs/how_to/serialization)
-
-## Use cases
-
-These guides cover use-case specific details.
-
-### Q&A with RAG
-
-Retrieval Augmented Generation (RAG) is a way to connect LLMs to external sources of data.
-For a high-level tutorial on RAG, check out [this guide](/docs/tutorials/rag/).
-
-- [How to: add chat history](/docs/how_to/qa_chat_history_how_to/)
-- [How to: stream](/docs/how_to/qa_streaming/)
-- [How to: return sources](/docs/how_to/qa_sources/)
-- [How to: return citations](/docs/how_to/qa_citations/)
-- [How to: do per-user retrieval](/docs/how_to/qa_per_user/)
-
-
-### Extraction
-
-Extraction is when you use LLMs to extract structured information from unstructured text.
-For a high level tutorial on extraction, check out [this guide](/docs/tutorials/extraction/).
-
-- [How to: use reference examples](/docs/how_to/extraction_examples/)
-- [How to: handle long text](/docs/how_to/extraction_long_text/)
-- [How to: do extraction without using function calling](/docs/how_to/extraction_parse)
-
-### Chatbots
-
-Chatbots involve using an LLM to have a conversation.
-For a high-level tutorial on building chatbots, check out [this guide](/docs/tutorials/chatbot/).
-
-- [How to: manage memory](/docs/how_to/chatbots_memory)
-- [How to: do retrieval](/docs/how_to/chatbots_retrieval)
-- [How to: use tools](/docs/how_to/chatbots_tools)
-- [How to: manage large chat history](/docs/how_to/trim_messages/)
-
-### Query analysis
-
-Query Analysis is the task of using an LLM to generate a query to send to a retriever.
-For a high-level tutorial on query analysis, check out [this guide](/docs/tutorials/query_analysis/).
-
-- [How to: add examples to the prompt](/docs/how_to/query_few_shot)
-- [How to: handle cases where no queries are generated](/docs/how_to/query_no_queries)
-- [How to: handle multiple queries](/docs/how_to/query_multiple_queries)
-- [How to: handle multiple retrievers](/docs/how_to/query_multiple_retrievers)
-- [How to: construct filters](/docs/how_to/query_constructing_filters)
-- [How to: deal with high cardinality categorical variables](/docs/how_to/query_high_cardinality)
-
-### Q&A over SQL + CSV
-
-You can use LLMs to do question answering over tabular data.
-For a high-level tutorial, check out [this guide](/docs/tutorials/sql_qa/).
-
-- [How to: use prompting to improve results](/docs/how_to/sql_prompting)
-- [How to: do query validation](/docs/how_to/sql_query_checking)
-- [How to: deal with large databases](/docs/how_to/sql_large_db)
-- [How to: deal with CSV files](/docs/how_to/sql_csv)
-
-### Q&A over graph databases
-
-You can use an LLM to do question answering over graph databases.
-For a high-level tutorial, check out [this guide](/docs/tutorials/graph/).
-
-- [How to: map values to a database](/docs/how_to/graph_mapping)
-- [How to: add a semantic layer over the database](/docs/how_to/graph_semantic)
-- [How to: improve results with prompting](/docs/how_to/graph_prompting)
-- [How to: construct knowledge graphs](/docs/how_to/graph_constructing)
-
-### Summarization
-
-LLMs can summarize and otherwise distill desired information from text, including
-large volumes of text. For a high-level tutorial, check out [this guide](/docs/tutorials/summarization).
-
-- [How to: summarize text in a single LLM call](/docs/how_to/summarize_stuff)
-- [How to: summarize text through parallelization](/docs/how_to/summarize_map_reduce)
-- [How to: summarize text through iterative refinement](/docs/how_to/summarize_refine)
-
-## [LangGraph](https://langchain-ai.github.io/langgraph)
-
-LangGraph is an extension of LangChain aimed at
-building robust and stateful multi-actor applications with LLMs by modeling steps as edges and nodes in a graph.
-
-LangGraph documentation is currently hosted on a separate site.
-You can peruse [LangGraph how-to guides here](https://langchain-ai.github.io/langgraph/how-tos/).
-
-## [LangSmith](https://docs.smith.langchain.com/)
-
-LangSmith allows you to closely trace, monitor and evaluate your LLM application.
-It seamlessly integrates with LangChain and LangGraph, and you can use it to inspect and debug individual steps of your chains and agents as you build.
-
-LangSmith documentation is hosted on a separate site.
-You can peruse [LangSmith how-to guides here](https://docs.smith.langchain.com/how_to_guides/), but we'll highlight a few sections that are particularly
-relevant to LangChain below:
-
-### Evaluation
-<span data-heading-keywords="evaluation,evaluate"></span>
-
-Evaluating performance is a vital part of building LLM-powered applications.
-LangSmith helps with every step of the process from creating a dataset to defining metrics to running evaluators.
-
-To learn more, check out the [LangSmith evaluation how-to guides](https://docs.smith.langchain.com/how_to_guides#evaluation).
-
-### Tracing
-<span data-heading-keywords="trace,tracing"></span>
-
-Tracing gives you observability inside your chains and agents, and is vital in diagnosing issues.
-
-- [How to: trace with LangChain](https://docs.smith.langchain.com/how_to_guides/tracing/trace_with_langchain)
-- [How to: add metadata and tags to traces](https://docs.smith.langchain.com/how_to_guides/tracing/trace_with_langchain#add-metadata-and-tags-to-traces)
-
-You can see general tracing-related how-tos [in this section of the LangSmith docs](https://docs.smith.langchain.com/how_to_guides/tracing).

langchain_md_files/how_to/installation.mdx

@@ -1,107 +0,0 @@
----
-sidebar_position: 2
----
-
-# How to install LangChain packages
-
-The LangChain ecosystem is split into different packages, which allow you to choose exactly which pieces of
-functionality to install.
-
-## Official release
-
-To install the main LangChain package, run:
-
-import Tabs from '@theme/Tabs';
-import TabItem from '@theme/TabItem';
-import CodeBlock from "@theme/CodeBlock";
-
-<Tabs>
-  <TabItem value="pip" label="Pip" default>
-    <CodeBlock language="bash">pip install langchain</CodeBlock>
-  </TabItem>
-  <TabItem value="conda" label="Conda">
-    <CodeBlock language="bash">conda install langchain -c conda-forge</CodeBlock>
-  </TabItem>
-</Tabs>
-
-While this package acts as a sane starting point to using LangChain,
-much of the value of LangChain comes when integrating it with various model providers, datastores, etc.
-By default, the dependencies needed to do that are NOT installed. You will need to install the dependencies for specific integrations separately.
-We'll show how to do that in the next sections of this guide.
-
-## Ecosystem packages
-
-With the exception of the `langsmith` SDK, all packages in the LangChain ecosystem depend on `langchain-core`, which contains base
-classes and abstractions that other packages use. The dependency graph below shows how the difference packages are related.
-A directed arrow indicates that the source package depends on the target package:
-
-![](/img/ecosystem_packages.png)
-
-When installing a package, you do not need to explicitly install that package's explicit dependencies (such as `langchain-core`).
-However, you may choose to if you are using a feature only available in a certain version of that dependency.
-If you do, you should make sure that the installed or pinned version is compatible with any other integration packages you use.
-
-### From source
-
-If you want to install from source, you can do so by cloning the repo and be sure that the directory is `PATH/TO/REPO/langchain/libs/langchain` running:
-
-```bash
-pip install -e .
-```
-
-### 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:
-
-```bash
-pip install langchain-core
-```
-
-### LangChain community
-The `langchain-community` package contains third-party integrations. 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:
-
-```bash
-pip install langchain-experimental
-```
-
-### LangGraph
-`langgraph` is a library for building stateful, multi-actor applications with LLMs. It integrates smoothly with LangChain, but can be used without it.
-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.
-If not using LangChain CLI, install with:
-
-```bash
-pip install "langserve[all]"
-```
-for both client and server dependencies. Or `pip install "langserve[client]"` for client code, and `pip install "langserve[server]"` for server code.
-
-## LangChain CLI
-The LangChain CLI is useful for working with LangChain templates and other LangServe projects.
-Install with:
-
-```bash
-pip install langchain-cli
-```
-
-### LangSmith SDK
-The LangSmith SDK is automatically installed by LangChain. However, it does not depend on
-`langchain-core`, and can be installed and used independently if desired.
-If you are not using LangChain, you can install it with:
-
-```bash
-pip install langsmith
-```

langchain_md_files/how_to/toolkits.mdx

@@ -1,21 +0,0 @@
----
-sidebar_position: 3
----
-# How to use toolkits
-
-
-Toolkits are collections of tools that are designed to be used together for specific tasks. They have convenient loading methods.
-
-All Toolkits expose a `get_tools` method which returns a list of tools.
-You can therefore do:
-
-```python
-# Initialize a toolkit
-toolkit = ExampleTookit(...)
-
-# Get list of tools
-tools = toolkit.get_tools()
-
-# Create agent
-agent = create_agent_method(llm, tools, prompt)
-```

langchain_md_files/how_to/vectorstores.mdx

@@ -1,178 +0,0 @@
-# How to create and query vector stores
-
-:::info
-Head to [Integrations](/docs/integrations/vectorstores/) for documentation on built-in integrations with 3rd-party vector stores.
-:::
-
-One of the most common ways to store and search over unstructured data is to embed it and store the resulting embedding
-vectors, and then at query time to embed the unstructured query and retrieve the embedding vectors that are
-'most similar' to the embedded query. A vector store takes care of storing embedded data and performing vector search
-for you.
-
-## Get started
-
-This guide showcases basic functionality related to vector stores. A key part of working with vector stores is creating the vector to put in them,
-which is usually created via embeddings. Therefore, it is recommended that you familiarize yourself with the [text embedding model interfaces](/docs/how_to/embed_text) before diving into this.
-
-Before using the vectorstore at all, we need to load some data and initialize an embedding model.
-
-We want to use OpenAIEmbeddings so we have to get the OpenAI API Key.
-
-```python
-import os
-import getpass
-
-os.environ['OPENAI_API_KEY'] = getpass.getpass('OpenAI API Key:')
-```
-
-```python
-from langchain_community.document_loaders import TextLoader
-from langchain_openai import OpenAIEmbeddings
-from langchain_text_splitters import CharacterTextSplitter
-
-# Load the document, split it into chunks, embed each chunk and load it into the vector store.
-raw_documents = TextLoader('state_of_the_union.txt').load()
-text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
-documents = text_splitter.split_documents(raw_documents)
-```
-
-import Tabs from '@theme/Tabs';
-import TabItem from '@theme/TabItem';
-
-There are many great vector store options, here are a few that are free, open-source, and run entirely on your local machine. Review all integrations for many great hosted offerings.
-
-
-<Tabs>
-  <TabItem value="chroma" label="Chroma" default>
-
-This walkthrough uses the `chroma` vector database, which runs on your local machine as a library.
-
-```bash
-pip install langchain-chroma
-```
-
-```python
-from langchain_chroma import Chroma
-
-db = Chroma.from_documents(documents, OpenAIEmbeddings())
-```
-
-  </TabItem>
-  <TabItem value="faiss" label="FAISS">
-
-This walkthrough uses the `FAISS` vector database, which makes use of the Facebook AI Similarity Search (FAISS) library.
-
-```bash
-pip install faiss-cpu
-```
-
-```python
-from langchain_community.vectorstores import FAISS
-
-db = FAISS.from_documents(documents, OpenAIEmbeddings())
-```
-
-  </TabItem>
-  <TabItem value="lance" label="Lance">
-
-This notebook shows how to use functionality related to the LanceDB vector database based on the Lance data format.
-
-```bash
-pip install lancedb
-```
-
-```python
-from langchain_community.vectorstores import LanceDB
-
-import lancedb
-
-db = lancedb.connect("/tmp/lancedb")
-table = db.create_table(
-    "my_table",
-    data=[
-        {
-            "vector": embeddings.embed_query("Hello World"),
-            "text": "Hello World",
-            "id": "1",
-        }
-    ],
-    mode="overwrite",
-)
-db = LanceDB.from_documents(documents, OpenAIEmbeddings())
-```
-
-  </TabItem>
-</Tabs>
-
-
-## Similarity search
-
-All vectorstores expose a `similarity_search` method.
-This will take incoming documents, create an embedding of them, and then find all documents with the most similar embedding.
-
-```python
-query = "What did the president say about Ketanji Brown Jackson"
-docs = db.similarity_search(query)
-print(docs[0].page_content)
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections.
-
-    Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service.
-
-    One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court.
-
-    And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.
-```
-
-</CodeOutputBlock>
-
-### Similarity search by vector
-
-It is also possible to do a search for documents similar to a given embedding vector using `similarity_search_by_vector` which accepts an embedding vector as a parameter instead of a string.
-
-```python
-embedding_vector = OpenAIEmbeddings().embed_query(query)
-docs = db.similarity_search_by_vector(embedding_vector)
-print(docs[0].page_content)
-```
-
-<CodeOutputBlock lang="python">
-
-```
-    Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections.
-
-    Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service.
-
-    One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court.
-
-    And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.
-```
-
-</CodeOutputBlock>
-
-## Async Operations
-
-
-Vector stores are usually run as a separate service that requires some IO operations, and therefore they might be called asynchronously. That gives performance benefits as you don't waste time waiting for responses from external services. That might also be important if you work with an asynchronous framework, such as [FastAPI](https://fastapi.tiangolo.com/).
-
-LangChain supports async operation on vector stores. All the methods might be called using their async counterparts, with the prefix `a`, meaning `async`.
-
-```python
-docs = await db.asimilarity_search(query)
-docs
-```
-
-<CodeOutputBlock lang="python">
-
-```
-[Document(page_content='Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections. \n\nTonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service. \n\nOne of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court. \n\nAnd I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.', metadata={'source': 'state_of_the_union.txt'}),
- Document(page_content='A former top litigator in private practice. A former federal public defender. And from a family of public school educators and police officers. A consensus builder. Since she’s been nominated, she’s received a broad range of support—from the Fraternal Order of Police to former judges appointed by Democrats and Republicans. \n\nAnd if we are to advance liberty and justice, we need to secure the Border and fix the immigration system. \n\nWe can do both. At our border, we’ve installed new technology like cutting-edge scanners to better detect drug smuggling.  \n\nWe’ve set up joint patrols with Mexico and Guatemala to catch more human traffickers.  \n\nWe’re putting in place dedicated immigration judges so families fleeing persecution and violence can have their cases heard faster. \n\nWe’re securing commitments and supporting partners in South and Central America to host more refugees and secure their own borders.', metadata={'source': 'state_of_the_union.txt'}),
- Document(page_content='And for our LGBTQ+ Americans, let’s finally get the bipartisan Equality Act to my desk. The onslaught of state laws targeting transgender Americans and their families is wrong. \n\nAs I said last year, especially to our younger transgender Americans, I will always have your back as your President, so you can be yourself and reach your God-given potential. \n\nWhile it often appears that we never agree, that isn’t true. I signed 80 bipartisan bills into law last year. From preventing government shutdowns to protecting Asian-Americans from still-too-common hate crimes to reforming military justice. \n\nAnd soon, we’ll strengthen the Violence Against Women Act that I first wrote three decades ago. It is important for us to show the nation that we can come together and do big things. \n\nSo tonight I’m offering a Unity Agenda for the Nation. Four big things we can do together.  \n\nFirst, beat the opioid epidemic.', metadata={'source': 'state_of_the_union.txt'}),
- Document(page_content='Tonight, I’m announcing a crackdown on these companies overcharging American businesses and consumers. \n\nAnd as Wall Street firms take over more nursing homes, quality in those homes has gone down and costs have gone up.  \n\nThat ends on my watch. \n\nMedicare is going to set higher standards for nursing homes and make sure your loved ones get the care they deserve and expect. \n\nWe’ll also cut costs and keep the economy going strong by giving workers a fair shot, provide more training and apprenticeships, hire them based on their skills not degrees. \n\nLet’s pass the Paycheck Fairness Act and paid leave.  \n\nRaise the minimum wage to $15 an hour and extend the Child Tax Credit, so no one has to raise a family in poverty. \n\nLet’s increase Pell Grants and increase our historic support of HBCUs, and invest in what Jill—our First Lady who teaches full-time—calls America’s best-kept secret: community colleges.', metadata={'source': 'state_of_the_union.txt'})]
-```
-
-</CodeOutputBlock>

langchain_md_files/integrations/chat/index.mdx

@@ -1,32 +0,0 @@
----
-sidebar_position: 0
-sidebar_class_name: hidden
-keywords: [compatibility]
----
-
-# Chat models
-
-[Chat models](/docs/concepts/#chat-models) are language models that use a sequence of [messages](/docs/concepts/#messages) as inputs and return messages as outputs (as opposed to using plain text). These are generally newer models.
-
-:::info
-
-If you'd like to write your own chat model, see [this how-to](/docs/how_to/custom_chat_model/).
-If you'd like to contribute an integration, see [Contributing integrations](/docs/contributing/integrations/).
-
-:::
-
-## Featured Providers
-
-:::info
-While all these LangChain classes support the indicated advanced feature, you may have
-to open the provider-specific documentation to learn which hosted models or backends support
-the feature.
-:::
-
-import { CategoryTable, IndexTable } from "@theme/FeatureTables";
-
-<CategoryTable category="chat" />
-
-## All chat models
-
-<IndexTable />

langchain_md_files/integrations/document_loaders/index.mdx

@@ -1,69 +0,0 @@
----
-sidebar_position: 0
-sidebar_class_name: hidden
----
-
-# Document loaders
-
-import { CategoryTable, IndexTable } from "@theme/FeatureTables";
-
-DocumentLoaders load data into the standard LangChain Document format.
-
-Each DocumentLoader has its own specific parameters, but they can all be invoked in the same way with the .load method.
-An example use case is as follows:
-
-```python
-from langchain_community.document_loaders.csv_loader import CSVLoader
-
-loader = CSVLoader(
-    ...  # <-- Integration specific parameters here
-)
-data = loader.load()
-```
-
-## Webpages
-
-The below document loaders allow you to load webpages.
-
-<CategoryTable category="webpage_loaders" />
-
-## PDFs
-
-The below document loaders allow you to load PDF documents.
-
-<CategoryTable category="pdf_loaders" />
-
-## Cloud Providers
-
-The below document loaders allow you to load documents from your favorite cloud providers.
-
-<CategoryTable category="cloud_provider_loaders"/>
-
-## Social Platforms
-
-The below document loaders allow you to load documents from differnt social media platforms.
-
-<CategoryTable category="social_loaders"/>
-
-## Messaging Services
-
-The below document loaders allow you to load data from different messaging platforms.
-
-<CategoryTable category="messaging_loaders"/>
-
-## Productivity tools
-
-The below document loaders allow you to load data from commonly used productivity tools.
-
-<CategoryTable category="productivity_loaders"/>
-
-## Common File Types
-
-The below document loaders allow you to load data from common data formats.
-
-<CategoryTable category="common_loaders" />
-
-
-## All document loaders
-
-<IndexTable />

langchain_md_files/integrations/graphs/tigergraph.mdx

@@ -1,37 +0,0 @@
-# TigerGraph
-
->[TigerGraph](https://www.tigergraph.com/tigergraph-db/) is a natively distributed and high-performance graph database.
-> The storage of data in a graph format of vertices and edges leads to rich relationships, 
-> ideal for grouding LLM responses.
- 
-A big example of the `TigerGraph` and `LangChain` integration [presented here](https://github.com/tigergraph/graph-ml-notebooks/blob/main/applications/large_language_models/TigerGraph_LangChain_Demo.ipynb).
-
-## Installation and Setup
-
-Follow instructions [how to connect to the `TigerGraph` database](https://docs.tigergraph.com/pytigergraph/current/getting-started/connection).
-
-Install the Python SDK:
-
-```bash
-pip install pyTigerGraph
-```
-
-## Example
-
-To utilize the `TigerGraph InquiryAI` functionality, you can import `TigerGraph` from `langchain_community.graphs`.
-
-```python
-import pyTigerGraph as tg
-
-conn = tg.TigerGraphConnection(host="DATABASE_HOST_HERE", graphname="GRAPH_NAME_HERE", username="USERNAME_HERE", password="PASSWORD_HERE")
-
-### ==== CONFIGURE INQUIRYAI HOST ====
-conn.ai.configureInquiryAIHost("INQUIRYAI_HOST_HERE")
-
-from langchain_community.graphs import TigerGraph
-
-graph = TigerGraph(conn)
-result = graph.query("How many servers are there?")
-print(result)
-```
-

langchain_md_files/integrations/llms/index.mdx

@@ -1,30 +0,0 @@
----
-sidebar_position: 0
-sidebar_class_name: hidden
-keywords: [compatibility]
----
-
-# LLMs
-
-:::caution
-You are currently on a page documenting the use of [text completion models](/docs/concepts/#llms). Many of the latest and most popular models are [chat completion models](/docs/concepts/#chat-models).
-
-Unless you are specifically using more advanced prompting techniques, you are probably looking for [this page instead](/docs/integrations/chat/).
-:::
-
-[LLMs](docs/concepts/#llms) are language models that take a string as input and return a string as output.
-
-:::info
-
-If you'd like to write your own LLM, see [this how-to](/docs/how_to/custom_llm/).
-If you'd like to contribute an integration, see [Contributing integrations](/docs/contributing/integrations/).
-
-:::
-
-import { CategoryTable, IndexTable } from "@theme/FeatureTables";
-
-<CategoryTable category="llms" />
-
-## All LLMs
-
-<IndexTable />

langchain_md_files/integrations/llms/layerup_security.mdx

@@ -1,85 +0,0 @@
-# Layerup Security
-
-The [Layerup Security](https://uselayerup.com) integration allows you to secure your calls to any LangChain LLM, LLM chain or LLM agent. The LLM object wraps around any existing LLM object, allowing for a secure layer between your users and your LLMs.
-
-While the Layerup Security object is designed as an LLM, it is not actually an LLM itself, it simply wraps around an LLM, allowing it to adapt the same functionality as the underlying LLM.
-
-## Setup
-First, you'll need a Layerup Security account from the Layerup [website](https://uselayerup.com).
-
-Next, create a project via the [dashboard](https://dashboard.uselayerup.com), and copy your API key. We recommend putting your API key in your project's environment.
-
-Install the Layerup Security SDK:
-```bash
-pip install LayerupSecurity
-```
-
-And install LangChain Community:
-```bash
-pip install langchain-community
-```
-
-And now you're ready to start protecting your LLM calls with Layerup Security!
-
-```python
-from langchain_community.llms.layerup_security import LayerupSecurity
-from langchain_openai import OpenAI
-
-# Create an instance of your favorite LLM
-openai = OpenAI(
-    model_name="gpt-3.5-turbo",
-    openai_api_key="OPENAI_API_KEY",
-)
-
-# Configure Layerup Security
-layerup_security = LayerupSecurity(
-    # Specify a LLM that Layerup Security will wrap around
-    llm=openai,
-
-    # Layerup API key, from the Layerup dashboard
-    layerup_api_key="LAYERUP_API_KEY",
-
-    # Custom base URL, if self hosting
-    layerup_api_base_url="https://api.uselayerup.com/v1",
-
-    # List of guardrails to run on prompts before the LLM is invoked
-    prompt_guardrails=[],
-
-    # List of guardrails to run on responses from the LLM
-    response_guardrails=["layerup.hallucination"],
-
-    # Whether or not to mask the prompt for PII & sensitive data before it is sent to the LLM
-    mask=False,
-
-    # Metadata for abuse tracking, customer tracking, and scope tracking.
-    metadata={"customer": "[email protected]"},
-
-    # Handler for guardrail violations on the prompt guardrails
-    handle_prompt_guardrail_violation=(
-        lambda violation: {
-            "role": "assistant",
-            "content": (
-                "There was sensitive data! I cannot respond. "
-                "Here's a dynamic canned response. Current date: {}"
-            ).format(datetime.now())
-        }
-        if violation["offending_guardrail"] == "layerup.sensitive_data"
-        else None
-    ),
-
-    # Handler for guardrail violations on the response guardrails
-    handle_response_guardrail_violation=(
-        lambda violation: {
-            "role": "assistant",
-            "content": (
-                "Custom canned response with dynamic data! "
-                "The violation rule was {}."
-            ).format(violation["offending_guardrail"])
-        }
-    ),
-)
-
-response = layerup_security.invoke(
-    "Summarize this message: my name is Bob Dylan. My SSN is 123-45-6789."
-)
-```

langchain_md_files/integrations/platforms/anthropic.mdx

@@ -1,43 +0,0 @@
-# Anthropic
-
->[Anthropic](https://www.anthropic.com/) is an AI safety and research company, and is the creator of `Claude`.
-This page covers all integrations between `Anthropic` models and `LangChain`.
-
-## Installation and Setup
-
-To use `Anthropic` models, you need to install a python package:
-
-```bash
-pip install -U langchain-anthropic
-```
-
-You need to set the `ANTHROPIC_API_KEY` environment variable.
-You can get an Anthropic API key [here](https://console.anthropic.com/settings/keys)
-
-## Chat Models
-
-### ChatAnthropic
-
-See a [usage example](/docs/integrations/chat/anthropic).
-
-```python
-from langchain_anthropic import ChatAnthropic
-
-model = ChatAnthropic(model='claude-3-opus-20240229')
-```
-
-
-## LLMs
-
-### [Legacy] AnthropicLLM
-
-**NOTE**: `AnthropicLLM` only supports legacy `Claude 2` models. 
-To use the newest `Claude 3` models, please use `ChatAnthropic` instead.
-
-See a [usage example](/docs/integrations/llms/anthropic).
-
-```python
-from langchain_anthropic import AnthropicLLM
-
-model = AnthropicLLM(model='claude-2.1')
-```

langchain_md_files/integrations/platforms/aws.mdx

@@ -1,381 +0,0 @@
-# AWS
-
-The `LangChain` integrations related to [Amazon AWS](https://aws.amazon.com/) platform.
-
-First-party AWS integrations are available in the `langchain_aws` package.
-
-```bash
-pip install langchain-aws
-```
-
-And there are also some community integrations available in the `langchain_community` package with the `boto3` optional dependency.
-
-```bash
-pip install langchain-community boto3
-```
-
-## Chat models
-
-### Bedrock Chat
-
->[Amazon Bedrock](https://aws.amazon.com/bedrock/) is a fully managed service that offers a choice of 
-> high-performing foundation models (FMs) from leading AI companies like `AI21 Labs`, `Anthropic`, `Cohere`, 
-> `Meta`, `Stability AI`, and `Amazon` via a single API, along with a broad set of capabilities you need to 
-> build generative AI applications with security, privacy, and responsible AI. Using `Amazon Bedrock`, 
-> you can easily experiment with and evaluate top FMs for your use case, privately customize them with 
-> your data using techniques such as fine-tuning and `Retrieval Augmented Generation` (`RAG`), and build 
-> agents that execute tasks using your enterprise systems and data sources. Since `Amazon Bedrock` is 
-> serverless, you don't have to manage any infrastructure, and you can securely integrate and deploy 
-> generative AI capabilities into your applications using the AWS services you are already familiar with.
-
-See a [usage example](/docs/integrations/chat/bedrock).
-
-```python
-from langchain_aws import ChatBedrock
-```
-
-### Bedrock Converse
-AWS has recently released the Bedrock Converse API which provides a unified conversational interface for Bedrock models. This API does not yet support custom models. You can see a list of all [models that are supported here](https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference.html). To improve reliability the ChatBedrock integration will switch to using the Bedrock Converse API as soon as it has feature parity with the existing Bedrock API. Until then a separate [ChatBedrockConverse](https://python.langchain.com/v0.2/api_reference/aws/chat_models/langchain_aws.chat_models.bedrock_converse.ChatBedrockConverse.html) integration has been released.
-
-We recommend using `ChatBedrockConverse` for users who do not need to use custom models. See the [docs](/docs/integrations/chat/bedrock/#bedrock-converse-api) and [API reference](https://python.langchain.com/v0.2/api_reference/aws/chat_models/langchain_aws.chat_models.bedrock_converse.ChatBedrockConverse.html) for more detail.
-
-```python
-from langchain_aws import ChatBedrockConverse
-```
-
-## LLMs
-
-### Bedrock
- 
-See a [usage example](/docs/integrations/llms/bedrock).
-
-```python
-from langchain_aws import BedrockLLM
-```
-
-### Amazon API Gateway
-
->[Amazon API Gateway](https://aws.amazon.com/api-gateway/) is a fully managed service that makes it easy for 
-> developers to create, publish, maintain, monitor, and secure APIs at any scale. APIs act as the "front door" 
-> for applications to access data, business logic, or functionality from your backend services. Using 
-> `API Gateway`, you can create RESTful APIs and WebSocket APIs that enable real-time two-way communication 
-> applications. `API Gateway` supports containerized and serverless workloads, as well as web applications.
-> 
-> `API Gateway` handles all the tasks involved in accepting and processing up to hundreds of thousands of 
-> concurrent API calls, including traffic management, CORS support, authorization and access control, 
-> throttling, monitoring, and API version management. `API Gateway` has no minimum fees or startup costs. 
-> You pay for the API calls you receive and the amount of data transferred out and, with the `API Gateway` 
-> tiered pricing model, you can reduce your cost as your API usage scales.
-
-See a [usage example](/docs/integrations/llms/amazon_api_gateway).
-
-```python
-from langchain_community.llms import AmazonAPIGateway
-```
-
-### SageMaker Endpoint
-
->[Amazon SageMaker](https://aws.amazon.com/sagemaker/) is a system that can build, train, and deploy 
-> machine learning (ML) models with fully managed infrastructure, tools, and workflows.
-
-We use `SageMaker` to host our model and expose it as the `SageMaker Endpoint`.
-
-See a [usage example](/docs/integrations/llms/sagemaker).
-
-```python
-from langchain_aws import SagemakerEndpoint
-```
-
-## Embedding Models
-
-### Bedrock
-
-See a [usage example](/docs/integrations/text_embedding/bedrock).
-```python
-from langchain_community.embeddings import BedrockEmbeddings
-```
-
-### SageMaker Endpoint
-
-See a [usage example](/docs/integrations/text_embedding/sagemaker-endpoint).
-```python
-from langchain_community.embeddings import SagemakerEndpointEmbeddings
-from langchain_community.llms.sagemaker_endpoint import ContentHandlerBase
-```
-
-## Document loaders
-
-### AWS S3 Directory and File
-
->[Amazon Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-folders.html)
-> is an object storage service.
->[AWS S3 Directory](https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-folders.html)
->[AWS S3 Buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingBucket.html)
-
-See a [usage example for S3DirectoryLoader](/docs/integrations/document_loaders/aws_s3_directory).
-
-See a [usage example for S3FileLoader](/docs/integrations/document_loaders/aws_s3_file).
-
-```python
-from langchain_community.document_loaders import S3DirectoryLoader, S3FileLoader
-```
-
-### Amazon Textract
-
->[Amazon Textract](https://docs.aws.amazon.com/managedservices/latest/userguide/textract.html) is a machine 
-> learning (ML) service that automatically extracts text, handwriting, and data from scanned documents.
-
-See a [usage example](/docs/integrations/document_loaders/amazon_textract).
-
-```python
-from langchain_community.document_loaders import AmazonTextractPDFLoader
-```
-
-### Amazon Athena
-
->[Amazon Athena](https://aws.amazon.com/athena/) is a serverless, interactive analytics service built
->on open-source frameworks, supporting open-table and file formats.
-
-See a [usage example](/docs/integrations/document_loaders/athena).
-
-```python
-from langchain_community.document_loaders.athena import AthenaLoader
-```
-
-### AWS Glue
-
->The [AWS Glue Data Catalog](https://docs.aws.amazon.com/en_en/glue/latest/dg/catalog-and-crawler.html) is a centralized metadata 
-> repository that allows you to manage, access, and share metadata about 
-> your data stored in AWS. It acts as a metadata store for your data assets, 
-> enabling various AWS services and your applications to query and connect 
-> to the data they need efficiently.
-
-See a [usage example](/docs/integrations/document_loaders/glue_catalog).
-
-```python
-from langchain_community.document_loaders.glue_catalog import GlueCatalogLoader
-```
-
-## Vector stores
-
-### Amazon OpenSearch Service
-
-> [Amazon OpenSearch Service](https://aws.amazon.com/opensearch-service/) performs 
-> interactive log analytics, real-time application monitoring, website search, and more. `OpenSearch` is 
-> an open source, 
-> distributed search and analytics suite derived from `Elasticsearch`. `Amazon OpenSearch Service` offers the 
-> latest versions of `OpenSearch`, support for many versions of `Elasticsearch`, as well as 
-> visualization capabilities powered by `OpenSearch Dashboards` and `Kibana`.
-
-We need to install several python libraries.
-
-```bash
-pip install boto3 requests requests-aws4auth
-```
-
-See a [usage example](/docs/integrations/vectorstores/opensearch#using-aos-amazon-opensearch-service).
-
-```python
-from langchain_community.vectorstores import OpenSearchVectorSearch
-```
-
-### Amazon DocumentDB Vector Search
-
->[Amazon DocumentDB (with MongoDB Compatibility)](https://docs.aws.amazon.com/documentdb/) makes it easy to set up, operate, and scale MongoDB-compatible databases in the cloud.
-> With Amazon DocumentDB, you can run the same application code and use the same drivers and tools that you use with MongoDB.
-> Vector search for Amazon DocumentDB combines the flexibility and rich querying capability of a JSON-based document database with the power of vector search.
-
-#### Installation and Setup
-
-See [detail configuration instructions](/docs/integrations/vectorstores/documentdb).
-
-We need to install the `pymongo` python package.
-
-```bash
-pip install pymongo
-```
-
-#### Deploy DocumentDB on AWS
-
-[Amazon DocumentDB (with MongoDB Compatibility)](https://docs.aws.amazon.com/documentdb/) is a fast, reliable, and fully managed database service. Amazon DocumentDB makes it easy to set up, operate, and scale MongoDB-compatible databases in the cloud.
-
-AWS offers services for computing, databases, storage, analytics, and other functionality. For an overview of all AWS services, see [Cloud Computing with Amazon Web Services](https://aws.amazon.com/what-is-aws/).
-
-See a [usage example](/docs/integrations/vectorstores/documentdb).
-
-```python
-from langchain_community.vectorstores import DocumentDBVectorSearch
-```
-### Amazon MemoryDB 
-[Amazon MemoryDB](https://aws.amazon.com/memorydb/) is a durable, in-memory database service that delivers ultra-fast performance. MemoryDB is compatible with Redis OSS, a popular open source data store, 
-enabling you to quickly build applications using the same flexible and friendly Redis OSS APIs, and commands that they already use today. 
-
-InMemoryVectorStore class provides a vectorstore to connect with Amazon MemoryDB.
-
-```python
-from langchain_aws.vectorstores.inmemorydb import InMemoryVectorStore
-
-vds = InMemoryVectorStore.from_documents(
-            chunks,
-            embeddings,
-            redis_url="rediss://cluster_endpoint:6379/ssl=True ssl_cert_reqs=none",
-            vector_schema=vector_schema,
-            index_name=INDEX_NAME,
-        )
-```
-See a [usage example](/docs/integrations/vectorstores/memorydb).
-
-## Retrievers
-
-### Amazon Kendra
-
-> [Amazon Kendra](https://docs.aws.amazon.com/kendra/latest/dg/what-is-kendra.html) is an intelligent search service 
-> provided by `Amazon Web Services` (`AWS`). It utilizes advanced natural language processing (NLP) and machine 
-> learning algorithms to enable powerful search capabilities across various data sources within an organization. 
-> `Kendra` is designed to help users find the information they need quickly and accurately, 
-> improving productivity and decision-making.
-
-> With `Kendra`, we can search across a wide range of content types, including documents, FAQs, knowledge bases, 
-> manuals, and websites. It supports multiple languages and can understand complex queries, synonyms, and 
-> contextual meanings to provide highly relevant search results.
-
-We need to install the `langchain-aws` library.
-
-```bash
-pip install langchain-aws
-```
-
-See a [usage example](/docs/integrations/retrievers/amazon_kendra_retriever).
-
-```python
-from langchain_aws import AmazonKendraRetriever
-```
-
-### Amazon Bedrock (Knowledge Bases)
-
-> [Knowledge bases for Amazon Bedrock](https://aws.amazon.com/bedrock/knowledge-bases/) is an 
-> `Amazon Web Services` (`AWS`) offering which lets you quickly build RAG applications by using your 
-> private data to customize foundation model response.
-
-We need to install the `langchain-aws` library.
-
-```bash
-pip install langchain-aws
-```
-
-See a [usage example](/docs/integrations/retrievers/bedrock).
-
-```python
-from langchain_aws import AmazonKnowledgeBasesRetriever
-```
-
-## Tools
-
-### AWS Lambda
-
->[`Amazon AWS Lambda`](https://aws.amazon.com/pm/lambda/) is a serverless computing service provided by 
-> `Amazon Web Services` (`AWS`). It helps developers to build and run applications and services without 
-> provisioning or managing servers. This serverless architecture enables you to focus on writing and 
-> deploying code, while AWS automatically takes care of scaling, patching, and managing the 
-> infrastructure required to run your applications.
-
-We need to install `boto3` python library.
-
-```bash
-pip install boto3
-```
-
-See a [usage example](/docs/integrations/tools/awslambda).
-
-## Memory
-
-### AWS DynamoDB
-
->[AWS DynamoDB](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/dynamodb/index.html) 
-> is a fully managed `NoSQL` database service that provides fast and predictable performance with seamless scalability.
- 
-We have to configure the [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html). 
-
-We need to install the `boto3` library.
-
-```bash
-pip install boto3
-```
-
-See a [usage example](/docs/integrations/memory/aws_dynamodb).
-
-```python
-from langchain_community.chat_message_histories import DynamoDBChatMessageHistory
-```
-
-## Graphs
-
-### Amazon Neptune with Cypher
-
-See a [usage example](/docs/integrations/graphs/amazon_neptune_open_cypher).
-
-```python
-from langchain_community.graphs import NeptuneGraph
-from langchain_community.graphs import NeptuneAnalyticsGraph
-from langchain_community.chains.graph_qa.neptune_cypher import NeptuneOpenCypherQAChain
-```
-
-### Amazon Neptune with SPARQL
-
-See a [usage example](/docs/integrations/graphs/amazon_neptune_sparql).
-
-```python
-from langchain_community.graphs import NeptuneRdfGraph
-from langchain_community.chains.graph_qa.neptune_sparql import NeptuneSparqlQAChain
-```
-
-
-
-## Callbacks
-
-### Bedrock token usage
-
-```python
-from langchain_community.callbacks.bedrock_anthropic_callback import BedrockAnthropicTokenUsageCallbackHandler
-```
-
-### SageMaker Tracking
-
->[Amazon SageMaker](https://aws.amazon.com/sagemaker/) is a fully managed service that is used to quickly 
-> and easily build, train and deploy machine learning (ML) models.
-
->[Amazon SageMaker Experiments](https://docs.aws.amazon.com/sagemaker/latest/dg/experiments.html) is a capability 
-> of `Amazon SageMaker` that lets you organize, track, 
-> compare and evaluate ML experiments and model versions.
- 
-We need to install several python libraries.
-
-```bash
-pip install google-search-results sagemaker
-```
-
-See a [usage example](/docs/integrations/callbacks/sagemaker_tracking).
-
-```python
-from langchain_community.callbacks import SageMakerCallbackHandler
-```
-
-## Chains
-
-### Amazon Comprehend Moderation Chain
-
->[Amazon Comprehend](https://aws.amazon.com/comprehend/) is a natural-language processing (NLP) service that 
-> uses machine learning to uncover valuable insights and connections in text.
-
-
-We need to install the `boto3` and `nltk` libraries.
-
-```bash
-pip install boto3 nltk
-```
-
-See a [usage example](https://python.langchain.com/v0.1/docs/guides/productionization/safety/amazon_comprehend_chain/).
-
-```python
-from langchain_experimental.comprehend_moderation import AmazonComprehendModerationChain
-```

langchain_md_files/integrations/platforms/google.mdx

@@ -1,1079 +0,0 @@
-# Google
-
-All functionality related to [Google Cloud Platform](https://cloud.google.com/) and other `Google` products.
-
-## Chat models
-
-We recommend individual developers to start with Gemini API (`langchain-google-genai`) and move to Vertex AI (`langchain-google-vertexai`) when they need access to commercial support and higher rate limits. If you’re already Cloud-friendly or Cloud-native, then you can get started in Vertex AI straight away.
-Please see [here](https://ai.google.dev/gemini-api/docs/migrate-to-cloud) for more information.
-
-### Google Generative AI
-
-Access GoogleAI `Gemini` models such as `gemini-pro` and `gemini-pro-vision` through the `ChatGoogleGenerativeAI` class.
-
-```bash
-pip install -U langchain-google-genai
-```
-
-Configure your API key.
-
-```bash
-export GOOGLE_API_KEY=your-api-key
-```
-
-```python
-from langchain_google_genai import ChatGoogleGenerativeAI
-
-llm = ChatGoogleGenerativeAI(model="gemini-pro")
-llm.invoke("Sing a ballad of LangChain.")
-```
-
-Gemini vision model supports image inputs when providing a single chat message.
-
-```python
-from langchain_core.messages import HumanMessage
-from langchain_google_genai import ChatGoogleGenerativeAI
-
-llm = ChatGoogleGenerativeAI(model="gemini-pro-vision")
-
-message = HumanMessage(
-    content=[
-        {
-            "type": "text",
-            "text": "What's in this image?",
-        },  # You can optionally provide text parts
-        {"type": "image_url", "image_url": "https://picsum.photos/seed/picsum/200/300"},
-    ]
-)
-llm.invoke([message])
-```
-
-The value of image_url can be any of the following:
-
-- A public image URL
-- A gcs file (e.g., "gcs://path/to/file.png")
-- A local file path
-- A base64 encoded image (e.g., data:image/png;base64,abcd124)
-- A PIL image
-
-### Vertex AI
-
-Access PaLM chat models like `chat-bison` and `codechat-bison` via Google Cloud.
-
-We need to install `langchain-google-vertexai` python package.
-
-```bash
-pip install langchain-google-vertexai
-```
-
-See a [usage example](/docs/integrations/chat/google_vertex_ai_palm).
-
-```python
-from langchain_google_vertexai import ChatVertexAI
-```
-
-### Chat Anthropic on Vertex AI
-
-See a [usage example](/docs/integrations/llms/google_vertex_ai_palm).
-
-```python
-from langchain_google_vertexai.model_garden import ChatAnthropicVertex
-```
-
-## LLMs
-
-### Google Generative AI
-
-Access GoogleAI `Gemini` models such as `gemini-pro` and `gemini-pro-vision` through the `GoogleGenerativeAI` class.
-
-Install python package.
-
-```bash
-pip install langchain-google-genai
-```
-
-See a [usage example](/docs/integrations/llms/google_ai).
-
-```python
-from langchain_google_genai import GoogleGenerativeAI
-```
-
-### Vertex AI Model Garden
-
-Access `PaLM` and hundreds of OSS models via `Vertex AI Model Garden` service.
-
-We need to install `langchain-google-vertexai` python package.
-
-```bash
-pip install langchain-google-vertexai
-```
-
-See a [usage example](/docs/integrations/llms/google_vertex_ai_palm#vertex-model-garden).
-
-```python
-from langchain_google_vertexai import VertexAIModelGarden
-```
-
-## Embedding models
-
-### Google Generative AI Embeddings
-
-See a [usage example](/docs/integrations/text_embedding/google_generative_ai).
-
-```bash
-pip install -U langchain-google-genai
-```
-
-Configure your API key.
-
-```bash
-export GOOGLE_API_KEY=your-api-key
-```
-
-```python
-from langchain_google_genai import GoogleGenerativeAIEmbeddings
-```
-
-### Vertex AI
-
-We need to install `langchain-google-vertexai` python package.
-
-```bash
-pip install langchain-google-vertexai
-```
-
-See a [usage example](/docs/integrations/text_embedding/google_vertex_ai_palm).
-
-```python
-from langchain_google_vertexai import VertexAIEmbeddings
-```
-
-### Palm Embedding
-
-We need to install `langchain-community` python package.
-
-```bash
-pip install langchain-community
-```
-
-```python
-from langchain_community.embeddings.google_palm import GooglePalmEmbeddings
-```
-
-## Document Loaders
-
-### AlloyDB for PostgreSQL
-
-> [Google Cloud AlloyDB](https://cloud.google.com/alloydb) is a fully managed relational database service that offers high performance, seamless integration, and impressive scalability on Google Cloud. AlloyDB is 100% compatible with PostgreSQL.
-
-Install the python package:
-
-```bash
-pip install langchain-google-alloydb-pg
-```
-
-See [usage example](/docs/integrations/document_loaders/google_alloydb).
-
-```python
-from langchain_google_alloydb_pg import AlloyDBEngine, AlloyDBLoader
-```
-
-### BigQuery
-
-> [Google Cloud BigQuery](https://cloud.google.com/bigquery) is a serverless and cost-effective enterprise data warehouse that works across clouds and scales with your data in Google Cloud.
-
-We need to install `langchain-google-community` with Big Query dependencies:
-
-```bash
-pip install langchain-google-community[bigquery]
-```
-
-See a [usage example](/docs/integrations/document_loaders/google_bigquery).
-
-```python
-from langchain_google_community import BigQueryLoader
-```
-
-### Bigtable
-
-> [Google Cloud Bigtable](https://cloud.google.com/bigtable/docs) is Google's fully managed NoSQL Big Data database service in Google Cloud.
-Install the python package:
-
-```bash
-pip install langchain-google-bigtable
-```
-
-See [Googel Cloud usage example](/docs/integrations/document_loaders/google_bigtable).
-
-```python
-from langchain_google_bigtable import BigtableLoader
-```
-
-### Cloud SQL for MySQL
-
-> [Google Cloud SQL for MySQL](https://cloud.google.com/sql) is a fully-managed database service that helps you set up, maintain, manage, and administer your MySQL relational databases on Google Cloud.
-Install the python package:
-
-```bash
-pip install langchain-google-cloud-sql-mysql
-```
-
-See [usage example](/docs/integrations/document_loaders/google_cloud_sql_mysql).
-
-```python
-from langchain_google_cloud_sql_mysql import MySQLEngine, MySQLDocumentLoader
-```
-
-### Cloud SQL for SQL Server
-
-> [Google Cloud SQL for SQL Server](https://cloud.google.com/sql) is a fully-managed database service that helps you set up, maintain, manage, and administer your SQL Server databases on Google Cloud.
-Install the python package:
-
-```bash
-pip install langchain-google-cloud-sql-mssql
-```
-
-See [usage example](/docs/integrations/document_loaders/google_cloud_sql_mssql).
-
-```python
-from langchain_google_cloud_sql_mssql import MSSQLEngine, MSSQLLoader
-```
-
-### Cloud SQL for PostgreSQL
-
-> [Google Cloud SQL for PostgreSQL](https://cloud.google.com/sql) is a fully-managed database service that helps you set up, maintain, manage, and administer your PostgreSQL relational databases on Google Cloud.
-Install the python package:
-
-```bash
-pip install langchain-google-cloud-sql-pg
-```
-
-See [usage example](/docs/integrations/document_loaders/google_cloud_sql_pg).
-
-```python
-from langchain_google_cloud_sql_pg import PostgresEngine, PostgresLoader
-```
-
-### Cloud Storage
-
->[Cloud Storage](https://en.wikipedia.org/wiki/Google_Cloud_Storage) is a managed service for storing unstructured data in Google Cloud.
-
-We need to install `langchain-google-community` with Google Cloud Storage dependencies.
-
-```bash
-pip install langchain-google-community[gcs]
-```
-
-There are two loaders for the `Google Cloud Storage`: the `Directory` and the `File` loaders.
-
-See a [usage example](/docs/integrations/document_loaders/google_cloud_storage_directory).
-
-```python
-from langchain_google_community import GCSDirectoryLoader
-```
-See a [usage example](/docs/integrations/document_loaders/google_cloud_storage_file).
-
-```python
-from langchain_google_community import GCSFileLoader
-```
-
-### Cloud Vision loader
-
-Install the python package:
-
-```bash
-pip install langchain-google-community[vision]
-```
-
-```python
-from langchain_google_community.vision import CloudVisionLoader
-```
-
-### El Carro for Oracle Workloads
-
-> Google [El Carro Oracle Operator](https://github.com/GoogleCloudPlatform/elcarro-oracle-operator)
-offers a way to run Oracle databases in Kubernetes as a portable, open source,
-community driven, no vendor lock-in container orchestration system.
-
-```bash
-pip install langchain-google-el-carro
-```
-
-See [usage example](/docs/integrations/document_loaders/google_el_carro).
-
-```python
-from langchain_google_el_carro import ElCarroLoader
-```
-
-### Google Drive
-
->[Google Drive](https://en.wikipedia.org/wiki/Google_Drive) is a file storage and synchronization service developed by Google.
-
-Currently, only `Google Docs` are supported.
-
-We need to install `langchain-google-community` with Google Drive dependencies.
-
-```bash
-pip install langchain-google-community[drive]
-```
-
-See a [usage example and authorization instructions](/docs/integrations/document_loaders/google_drive).
-
-```python
-from langchain_google_community import GoogleDriveLoader
-```
-
-### Firestore (Native Mode)
-
-> [Google Cloud Firestore](https://cloud.google.com/firestore/docs/) is a NoSQL document database built for automatic scaling, high performance, and ease of application development.
-Install the python package:
-
-```bash
-pip install langchain-google-firestore
-```
-
-See [usage example](/docs/integrations/document_loaders/google_firestore).
-
-```python
-from langchain_google_firestore import FirestoreLoader
-```
-
-### Firestore (Datastore Mode)
-
-> [Google Cloud Firestore in Datastore mode](https://cloud.google.com/datastore/docs) is a NoSQL document database built for automatic scaling, high performance, and ease of application development.
-> Firestore is the newest version of Datastore and introduces several improvements over Datastore.
-Install the python package:
-
-```bash
-pip install langchain-google-datastore
-```
-
-See [usage example](/docs/integrations/document_loaders/google_datastore).
-
-```python
-from langchain_google_datastore import DatastoreLoader
-```
-
-### Memorystore for Redis
-
-> [Google Cloud Memorystore for Redis](https://cloud.google.com/memorystore/docs/redis) is a fully managed Redis service for Google Cloud. Applications running on Google Cloud can achieve extreme performance by leveraging the highly scalable, available, secure Redis service without the burden of managing complex Redis deployments.
-Install the python package:
-
-```bash
-pip install langchain-google-memorystore-redis
-```
-
-See [usage example](/docs/integrations/document_loaders/google_memorystore_redis).
-
-```python
-from langchain_google_memorystore_redis import MemorystoreLoader
-```
-
-### Spanner
-
-> [Google Cloud Spanner](https://cloud.google.com/spanner/docs) is a fully managed, mission-critical, relational database service on Google Cloud that offers transactional consistency at global scale, automatic, synchronous replication for high availability, and support for two SQL dialects: GoogleSQL (ANSI 2011 with extensions) and PostgreSQL.
-Install the python package:
-
-```bash
-pip install langchain-google-spanner
-```
-
-See [usage example](/docs/integrations/document_loaders/google_spanner).
-
-```python
-from langchain_google_spanner import SpannerLoader
-```
-
-### Speech-to-Text
-
-> [Google Cloud Speech-to-Text](https://cloud.google.com/speech-to-text) is an audio transcription API powered by Google's speech recognition models in Google Cloud.
-
-This document loader transcribes audio files and outputs the text results as Documents.
-
-First, we need to install `langchain-google-community` with speech-to-text dependencies.
-
-```bash
-pip install langchain-google-community[speech]
-```
-
-See a [usage example and authorization instructions](/docs/integrations/document_loaders/google_speech_to_text).
-
-```python
-from langchain_google_community import SpeechToTextLoader
-```
-
-## Document Transformers
-
-### Document AI
-
->[Google Cloud Document AI](https://cloud.google.com/document-ai/docs/overview) is a Google Cloud
-> service that transforms unstructured data from documents into structured data, making it easier
-> to understand, analyze, and consume.
-
-We need to set up a [`GCS` bucket and create your own OCR processor](https://cloud.google.com/document-ai/docs/create-processor)
-The `GCS_OUTPUT_PATH` should be a path to a folder on GCS (starting with `gs://`)
-and a processor name should look like `projects/PROJECT_NUMBER/locations/LOCATION/processors/PROCESSOR_ID`.
-We can get it either programmatically or copy from the `Prediction endpoint` section of the `Processor details`
-tab in the Google Cloud Console.
-
-```bash
-pip install langchain-google-community[docai]
-```
-
-See a [usage example](/docs/integrations/document_transformers/google_docai).
-
-```python
-from langchain_core.document_loaders.blob_loaders import Blob
-from langchain_google_community import DocAIParser
-```
-
-### Google Translate
-
-> [Google Translate](https://translate.google.com/) is a multilingual neural machine
-> translation service developed by Google to translate text, documents and websites
-> from one language into another.
-
-The `GoogleTranslateTransformer` allows you to translate text and HTML with the [Google Cloud Translation API](https://cloud.google.com/translate).
-
-First, we need to install the `langchain-google-community` with translate dependencies.
-
-```bash
-pip install langchain-google-community[translate]
-```
-
-See a [usage example and authorization instructions](/docs/integrations/document_transformers/google_translate).
-
-```python
-from langchain_google_community import GoogleTranslateTransformer
-```
-
-## Vector Stores
-
-### AlloyDB for PostgreSQL
-
-> [Google Cloud AlloyDB](https://cloud.google.com/alloydb) is a fully managed relational database service that offers high performance, seamless integration, and impressive scalability on Google Cloud. AlloyDB is 100% compatible with PostgreSQL.
-
-Install the python package:
-
-```bash
-pip install langchain-google-alloydb-pg
-```
-
-See [usage example](/docs/integrations/vectorstores/google_alloydb).
-
-```python
-from langchain_google_alloydb_pg import AlloyDBEngine, AlloyDBVectorStore
-```
-
-### BigQuery Vector Search
-
-> [Google Cloud BigQuery](https://cloud.google.com/bigquery),
-> BigQuery is a serverless and cost-effective enterprise data warehouse in Google Cloud.
->
-> [Google Cloud BigQuery Vector Search](https://cloud.google.com/bigquery/docs/vector-search-intro)
-> BigQuery vector search lets you use GoogleSQL to do semantic search, using vector indexes for fast but approximate results, or using brute force for exact results.
-
-> It can calculate Euclidean or Cosine distance. With LangChain, we default to use Euclidean distance.
-
-We need to install several python packages.
-
-```bash
-pip install google-cloud-bigquery
-```
-
-See a [usage example](/docs/integrations/vectorstores/google_bigquery_vector_search).
-
-```python
-from langchain.vectorstores import BigQueryVectorSearch
-```
-
-### Memorystore for Redis
-
-> [Google Cloud Memorystore for Redis](https://cloud.google.com/memorystore/docs/redis) is a fully managed Redis service for Google Cloud. Applications running on Google Cloud can achieve extreme performance by leveraging the highly scalable, available, secure Redis service without the burden of managing complex Redis deployments.
-Install the python package:
-
-```bash
-pip install langchain-google-memorystore-redis
-```
-
-See [usage example](/docs/integrations/vectorstores/google_memorystore_redis).
-
-```python
-from langchain_google_memorystore_redis import RedisVectorStore
-```
-
-### Spanner
-
-> [Google Cloud Spanner](https://cloud.google.com/spanner/docs) is a fully managed, mission-critical, relational database service on Google Cloud that offers transactional consistency at global scale, automatic, synchronous replication for high availability, and support for two SQL dialects: GoogleSQL (ANSI 2011 with extensions) and PostgreSQL.
-Install the python package:
-
-```bash
-pip install langchain-google-spanner
-```
-
-See [usage example](/docs/integrations/vectorstores/google_spanner).
-
-```python
-from langchain_google_spanner import SpannerVectorStore
-```
-
-### Firestore (Native Mode)
-
-> [Google Cloud Firestore](https://cloud.google.com/firestore/docs/) is a NoSQL document database built for automatic scaling, high performance, and ease of application development.
-Install the python package:
-
-```bash
-pip install langchain-google-firestore
-```
-
-See [usage example](/docs/integrations/vectorstores/google_firestore).
-
-```python
-from langchain_google_firestore import FirestoreVectorstore
-```
-
-### Cloud SQL for MySQL
-
-> [Google Cloud SQL for MySQL](https://cloud.google.com/sql) is a fully-managed database service that helps you set up, maintain, manage, and administer your MySQL relational databases on Google Cloud.
-Install the python package:
-
-```bash
-pip install langchain-google-cloud-sql-mysql
-```
-
-See [usage example](/docs/integrations/vectorstores/google_cloud_sql_mysql).
-
-```python
-from langchain_google_cloud_sql_mysql import MySQLEngine, MySQLVectorStore
-```
-
-### Cloud SQL for PostgreSQL
-
-> [Google Cloud SQL for PostgreSQL](https://cloud.google.com/sql) is a fully-managed database service that helps you set up, maintain, manage, and administer your PostgreSQL relational databases on Google Cloud.
-Install the python package:
-
-```bash
-pip install langchain-google-cloud-sql-pg
-```
-
-See [usage example](/docs/integrations/vectorstores/google_cloud_sql_pg).
-
-```python
-from langchain_google_cloud_sql_pg import PostgresEngine, PostgresVectorStore
-```
-
-### Vertex AI Vector Search
-
-> [Google Cloud Vertex AI Vector Search](https://cloud.google.com/vertex-ai/docs/vector-search/overview) from Google Cloud,
-> formerly known as `Vertex AI Matching Engine`, provides the industry's leading high-scale
-> low latency vector database. These vector databases are commonly
-> referred to as vector similarity-matching or an approximate nearest neighbor (ANN) service.
-
-Install the python package:
-
-```bash
-pip install langchain-google-vertexai
-```
-
-See a [usage example](/docs/integrations/vectorstores/google_vertex_ai_vector_search).
-
-```python
-from langchain_google_vertexai import VectorSearchVectorStore
-```
-
-### ScaNN
-
->[Google ScaNN](https://github.com/google-research/google-research/tree/master/scann)
-> (Scalable Nearest Neighbors) is a python package.
->
->`ScaNN` is a method for efficient vector similarity search at scale.
-
->`ScaNN` includes search space pruning and quantization for Maximum Inner
-> Product Search and also supports other distance functions such as
-> Euclidean distance. The implementation is optimized for x86 processors
-> with AVX2 support. See its [Google Research github](https://github.com/google-research/google-research/tree/master/scann)
-> for more details.
-
-We need to install `scann` python package.
-
-```bash
-pip install scann
-```
-
-See a [usage example](/docs/integrations/vectorstores/scann).
-
-```python
-from langchain_community.vectorstores import ScaNN
-```
-
-## Retrievers
-
-### Google Drive
-
-We need to install several python packages.
-
-```bash
-pip install google-api-python-client google-auth-httplib2 google-auth-oauthlib
-```
-
-See a [usage example and authorization instructions](/docs/integrations/retrievers/google_drive).
-
-```python
-from langchain_googledrive.retrievers import GoogleDriveRetriever
-```
-
-### Vertex AI Search
-
-> [Vertex AI Search](https://cloud.google.com/generative-ai-app-builder/docs/introduction)
-> from Google Cloud allows developers to quickly build generative AI powered search engines for customers and employees.
-
-We need to install the `google-cloud-discoveryengine` python package.
-
-```bash
-pip install google-cloud-discoveryengine
-```
-
-See a [usage example](/docs/integrations/retrievers/google_vertex_ai_search).
-
-```python
-from langchain.retrievers import GoogleVertexAISearchRetriever
-```
-
-### Document AI Warehouse
-
-> [Document AI Warehouse](https://cloud.google.com/document-ai-warehouse)
-> from Google Cloud allows enterprises to search, store, govern, and manage documents and their AI-extracted
-> data and metadata in a single platform.
-
-Note: `GoogleDocumentAIWarehouseRetriever` is deprecated, use `DocumentAIWarehouseRetriever` (see below).
-```python
-from langchain.retrievers import GoogleDocumentAIWarehouseRetriever
-docai_wh_retriever = GoogleDocumentAIWarehouseRetriever(
-    project_number=...
-)
-query = ...
-documents = docai_wh_retriever.invoke(
-    query, user_ldap=...
-)
-```
-
-```python
-from langchain_google_community.documentai_warehouse import DocumentAIWarehouseRetriever
-```
-
-## Tools
-
-### Text-to-Speech
-
->[Google Cloud Text-to-Speech](https://cloud.google.com/text-to-speech) is a Google Cloud service that enables developers to
-> synthesize natural-sounding speech with 100+ voices, available in multiple languages and variants.
-> It applies DeepMind’s groundbreaking research in WaveNet and Google’s powerful neural networks
-> to deliver the highest fidelity possible.
-
-We need to install a python package.
-
-```bash
-pip install google-cloud-text-to-speech
-```
-
-See a [usage example and authorization instructions](/docs/integrations/tools/google_cloud_texttospeech).
-
-```python
-from langchain_google_community import TextToSpeechTool
-```
-
-### Google Drive
-
-We need to install several python packages.
-
-```bash
-pip install google-api-python-client google-auth-httplib2 google-auth-oauthlib
-```
-
-See a [usage example and authorization instructions](/docs/integrations/tools/google_drive).
-
-```python
-from langchain_community.utilities.google_drive import GoogleDriveAPIWrapper
-from langchain_community.tools.google_drive.tool import GoogleDriveSearchTool
-```
-
-### Google Finance
-
-We need to install a python package.
-
-```bash
-pip install google-search-results
-```
-
-See a [usage example and authorization instructions](/docs/integrations/tools/google_finance).
-
-```python
-from langchain_community.tools.google_finance import GoogleFinanceQueryRun
-from langchain_community.utilities.google_finance import GoogleFinanceAPIWrapper
-```
-
-### Google Jobs
-
-We need to install a python package.
-
-```bash
-pip install google-search-results
-```
-
-See a [usage example and authorization instructions](/docs/integrations/tools/google_jobs).
-
-```python
-from langchain_community.tools.google_jobs import GoogleJobsQueryRun
-from langchain_community.utilities.google_finance import GoogleFinanceAPIWrapper
-```
-
-### Google Lens
-
-See a [usage example and authorization instructions](/docs/integrations/tools/google_lens).
-
-```python
-from langchain_community.tools.google_lens import GoogleLensQueryRun
-from langchain_community.utilities.google_lens import GoogleLensAPIWrapper
-```
-
-### Google Places
-
-We need to install a python package.
-
-```bash
-pip install googlemaps
-```
-
-See a [usage example and authorization instructions](/docs/integrations/tools/google_places).
-
-```python
-from langchain.tools import GooglePlacesTool
-```
-
-### Google Scholar
-
-We need to install a python package.
-
-```bash
-pip install google-search-results
-```
-
-See a [usage example and authorization instructions](/docs/integrations/tools/google_scholar).
-
-```python
-from langchain_community.tools.google_scholar import GoogleScholarQueryRun
-from langchain_community.utilities.google_scholar import GoogleScholarAPIWrapper
-```
-
-### Google Search
-
-- Set up a Custom Search Engine, following [these instructions](https://stackoverflow.com/questions/37083058/programmatically-searching-google-in-python-using-custom-search)
-- Get an API Key and Custom Search Engine ID from the previous step, and set them as environment variables
-`GOOGLE_API_KEY` and `GOOGLE_CSE_ID` respectively.
-
-```python
-from langchain_google_community import GoogleSearchAPIWrapper
-```
-
-For a more detailed walkthrough of this wrapper, see [this notebook](/docs/integrations/tools/google_search).
-
-We can easily load this wrapper as a Tool (to use with an Agent). We can do this with:
-
-```python
-from langchain.agents import load_tools
-tools = load_tools(["google-search"])
-```
-
-### Google Trends
-
-We need to install a python package.
-
-```bash
-pip install google-search-results
-```
-
-See a [usage example and authorization instructions](/docs/integrations/tools/google_trends).
-
-```python
-from langchain_community.tools.google_trends import GoogleTrendsQueryRun
-from langchain_community.utilities.google_trends import GoogleTrendsAPIWrapper
-```
-
-## Toolkits
-
-### GMail
-
-> [Google Gmail](https://en.wikipedia.org/wiki/Gmail) is a free email service provided by Google.
-This toolkit works with emails through the `Gmail API`.
-
-We need to install `langchain-google-community` with required dependencies:
-
-```bash
-pip install langchain-google-community[gmail]
-```
-
-See a [usage example and authorization instructions](/docs/integrations/tools/gmail).
-
-```python
-from langchain_google_community import GmailToolkit
-```
-
-## Memory
-
-### AlloyDB for PostgreSQL
-
-> [AlloyDB for PostgreSQL](https://cloud.google.com/alloydb) is a fully managed relational database service that offers high performance, seamless integration, and impressive scalability on Google Cloud. AlloyDB is 100% compatible with PostgreSQL.
-
-Install the python package:
-
-```bash
-pip install langchain-google-alloydb-pg
-```
-
-See [usage example](/docs/integrations/memory/google_alloydb).
-
-```python
-from langchain_google_alloydb_pg import AlloyDBEngine, AlloyDBChatMessageHistory
-```
-
-### Cloud SQL for PostgreSQL
-
-> [Cloud SQL for PostgreSQL](https://cloud.google.com/sql) is a fully-managed database service that helps you set up, maintain, manage, and administer your PostgreSQL relational databases on Google Cloud.
-Install the python package:
-
-```bash
-pip install langchain-google-cloud-sql-pg
-```
-
-See [usage example](/docs/integrations/memory/google_sql_pg).
-
-
-```python
-from langchain_google_cloud_sql_pg import PostgresEngine, PostgresChatMessageHistory
-```
-
-### Cloud SQL for MySQL
-
-> [Cloud SQL for MySQL](https://cloud.google.com/sql) is a fully-managed database service that helps you set up, maintain, manage, and administer your MySQL relational databases on Google Cloud.
-Install the python package:
-
-```bash
-pip install langchain-google-cloud-sql-mysql
-```
-
-See [usage example](/docs/integrations/memory/google_sql_mysql).
-
-```python
-from langchain_google_cloud_sql_mysql import MySQLEngine, MySQLChatMessageHistory
-```
-
-### Cloud SQL for SQL Server
-
-> [Cloud SQL for SQL Server](https://cloud.google.com/sql) is a fully-managed database service that helps you set up, maintain, manage, and administer your SQL Server databases on Google Cloud.
-Install the python package:
-
-```bash
-pip install langchain-google-cloud-sql-mssql
-```
-
-See [usage example](/docs/integrations/memory/google_sql_mssql).
-
-```python
-from langchain_google_cloud_sql_mssql import MSSQLEngine, MSSQLChatMessageHistory
-```
-
-### Spanner
-
-> [Google Cloud Spanner](https://cloud.google.com/spanner/docs) is a fully managed, mission-critical, relational database service on Google Cloud that offers transactional consistency at global scale, automatic, synchronous replication for high availability, and support for two SQL dialects: GoogleSQL (ANSI 2011 with extensions) and PostgreSQL.
-Install the python package:
-
-```bash
-pip install langchain-google-spanner
-```
-
-See [usage example](/docs/integrations/memory/google_spanner).
-
-```python
-from langchain_google_spanner import SpannerChatMessageHistory
-```
-
-### Memorystore for Redis
-
-> [Google Cloud Memorystore for Redis](https://cloud.google.com/memorystore/docs/redis) is a fully managed Redis service for Google Cloud. Applications running on Google Cloud can achieve extreme performance by leveraging the highly scalable, available, secure Redis service without the burden of managing complex Redis deployments.
-Install the python package:
-
-```bash
-pip install langchain-google-memorystore-redis
-```
-
-See [usage example](/docs/integrations/document_loaders/google_memorystore_redis).
-
-```python
-from langchain_google_memorystore_redis import MemorystoreChatMessageHistory
-```
-
-### Bigtable
-
-> [Google Cloud Bigtable](https://cloud.google.com/bigtable/docs) is Google's fully managed NoSQL Big Data database service in Google Cloud.
-Install the python package:
-
-```bash
-pip install langchain-google-bigtable
-```
-
-See [usage example](/docs/integrations/memory/google_bigtable).
-
-```python
-from langchain_google_bigtable import BigtableChatMessageHistory
-```
-
-### Firestore (Native Mode)
-
-> [Google Cloud Firestore](https://cloud.google.com/firestore/docs/) is a NoSQL document database built for automatic scaling, high performance, and ease of application development.
-Install the python package:
-
-```bash
-pip install langchain-google-firestore
-```
-
-See [usage example](/docs/integrations/memory/google_firestore).
-
-```python
-from langchain_google_firestore import FirestoreChatMessageHistory
-```
-
-### Firestore (Datastore Mode)
-
-> [Google Cloud Firestore in Datastore mode](https://cloud.google.com/datastore/docs) is a NoSQL document database built for automatic scaling, high performance, and ease of application development.
-> Firestore is the newest version of Datastore and introduces several improvements over Datastore.
-Install the python package:
-
-```bash
-pip install langchain-google-datastore
-```
-
-See [usage example](/docs/integrations/memory/google_firestore_datastore).
-
-```python
-from langchain_google_datastore import DatastoreChatMessageHistory
-```
-
-### El Carro: The Oracle Operator for Kubernetes
-
-> Google [El Carro Oracle Operator for Kubernetes](https://github.com/GoogleCloudPlatform/elcarro-oracle-operator)
-offers a way to run `Oracle` databases in `Kubernetes` as a portable, open source,
-community driven, no vendor lock-in container orchestration system.
-
-```bash
-pip install langchain-google-el-carro
-```
-
-See [usage example](/docs/integrations/memory/google_el_carro).
-
-```python
-from langchain_google_el_carro import ElCarroChatMessageHistory
-```
-
-## Chat Loaders
-
-### GMail
-
-> [Gmail](https://en.wikipedia.org/wiki/Gmail) is a free email service provided by Google.
-This loader works with emails through the `Gmail API`.
-
-We need to install `langchain-google-community` with underlying dependencies.
-
-```bash
-pip install langchain-google-community[gmail]
-```
-
-See a [usage example and authorization instructions](/docs/integrations/chat_loaders/gmail).
-
-```python
-from langchain_google_community import GMailLoader
-```
-
-## 3rd Party Integrations
-
-### SearchApi
-
->[SearchApi](https://www.searchapi.io/) provides a 3rd-party API to access Google search results, YouTube search & transcripts, and other Google-related engines.
-
-See [usage examples and authorization instructions](/docs/integrations/tools/searchapi).
-
-```python
-from langchain_community.utilities import SearchApiAPIWrapper
-```
-
-### SerpApi
-
->[SerpApi](https://serpapi.com/) provides a 3rd-party API to access Google search results.
-
-See a [usage example and authorization instructions](/docs/integrations/tools/serpapi).
-
-```python
-from langchain_community.utilities import SerpAPIWrapper
-```
-
-### Serper.dev
-
-See a [usage example and authorization instructions](/docs/integrations/tools/google_serper).
-
-```python
-from langchain_community.utilities import GoogleSerperAPIWrapper
-```
-
-### YouTube
-
->[YouTube Search](https://github.com/joetats/youtube_search) package searches `YouTube` videos avoiding using their heavily rate-limited API.
->
->It uses the form on the YouTube homepage and scrapes the resulting page.
-
-We need to install a python package.
-
-```bash
-pip install youtube_search
-```
-
-See a [usage example](/docs/integrations/tools/youtube).
-
-```python
-from langchain.tools import YouTubeSearchTool
-```
-
-### YouTube audio
-
->[YouTube](https://www.youtube.com/) is an online video sharing and social media platform created by `Google`.
-
-Use `YoutubeAudioLoader` to fetch / download the audio files.
-
-Then, use `OpenAIWhisperParser` to transcribe them to text.
-
-We need to install several python packages.
-
-```bash
-pip install yt_dlp pydub librosa
-```
-
-See a [usage example and authorization instructions](/docs/integrations/document_loaders/youtube_audio).
-
-```python
-from langchain_community.document_loaders.blob_loaders.youtube_audio import YoutubeAudioLoader
-from langchain_community.document_loaders.parsers import OpenAIWhisperParser, OpenAIWhisperParserLocal
-```
-
-### YouTube transcripts
-
->[YouTube](https://www.youtube.com/) is an online video sharing and social media platform created by `Google`.
-
-We need to install `youtube-transcript-api` python package.
-
-```bash
-pip install youtube-transcript-api
-```
-
-See a [usage example](/docs/integrations/document_loaders/youtube_transcript).
-
-```python
-from langchain_community.document_loaders import YoutubeLoader
-```

langchain_md_files/integrations/platforms/huggingface.mdx

@@ -1,126 +0,0 @@
-# Hugging Face
-
-All functionality related to the [Hugging Face Platform](https://huggingface.co/).
-
-## Installation
-
-Most of the Hugging Face integrations are available in the `langchain-huggingface` package.
-
-```bash
-pip install langchain-huggingface
-```
-
-## Chat models
-
-### Models from Hugging Face
-
-We can use the `Hugging Face` LLM classes or directly use the `ChatHuggingFace` class.
-
-See a [usage example](/docs/integrations/chat/huggingface).
-
-```python
-from langchain_huggingface import ChatHuggingFace
-```
-
-## LLMs
-
-### Hugging Face Local Pipelines
-
-Hugging Face models can be run locally through the `HuggingFacePipeline` class.
-
-See a [usage example](/docs/integrations/llms/huggingface_pipelines).
-
-```python
-from langchain_huggingface import HuggingFacePipeline
-```
-
-## Embedding Models
-
-### HuggingFaceEmbeddings
-
-See a [usage example](/docs/integrations/text_embedding/huggingfacehub).
-
-```python
-from langchain_huggingface import HuggingFaceEmbeddings
-```
-
-### HuggingFaceInstructEmbeddings
-
-See a [usage example](/docs/integrations/text_embedding/instruct_embeddings).
-
-```python
-from langchain_community.embeddings import HuggingFaceInstructEmbeddings
-```
-
-### HuggingFaceBgeEmbeddings
-
->[BGE models on the HuggingFace](https://huggingface.co/BAAI/bge-large-en) are [the best open-source embedding models](https://huggingface.co/spaces/mteb/leaderboard).
->BGE model is created by the [Beijing Academy of Artificial Intelligence (BAAI)](https://en.wikipedia.org/wiki/Beijing_Academy_of_Artificial_Intelligence). `BAAI` is a private non-profit organization engaged in AI research and development.
-
-See a [usage example](/docs/integrations/text_embedding/bge_huggingface).
-
-```python
-from langchain_community.embeddings import HuggingFaceBgeEmbeddings
-```
-
-### Hugging Face Text Embeddings Inference (TEI)
-
->[Hugging Face Text Embeddings Inference (TEI)](https://huggingface.co/docs/text-generation-inference/index) is a toolkit for deploying and serving open-source
-> text embeddings and sequence classification models. `TEI` enables high-performance extraction for the most popular models,
->including `FlagEmbedding`, `Ember`, `GTE` and `E5`.
-
-We need to install `huggingface-hub` python package.
-
-```bash
-pip install huggingface-hub
-```
-
-See a [usage example](/docs/integrations/text_embedding/text_embeddings_inference).
-
-```python
-from langchain_community.embeddings import HuggingFaceHubEmbeddings
-```
-
-
-## Document Loaders
-
-### Hugging Face dataset
-
->[Hugging Face Hub](https://huggingface.co/docs/hub/index) is home to over 75,000 
-> [datasets](https://huggingface.co/docs/hub/index#datasets) in more than 100 languages 
-> that can be used for a broad range of tasks across NLP, Computer Vision, and Audio.
-> They used for a diverse range of tasks such as translation, automatic speech 
-> recognition, and image classification.
-
-We need to install `datasets` python package.
-
-```bash
-pip install datasets
-```
-
-See a [usage example](/docs/integrations/document_loaders/hugging_face_dataset).
-
-```python
-from langchain_community.document_loaders.hugging_face_dataset import HuggingFaceDatasetLoader
-```
-
-
-
-## Tools
-
-### Hugging Face Hub Tools
-
->[Hugging Face Tools](https://huggingface.co/docs/transformers/v4.29.0/en/custom_tools) 
-> support text I/O and are loaded using the `load_huggingface_tool` function.
-
-We need to install several python packages.
-
-```bash
-pip install transformers huggingface_hub
-```
-
-See a [usage example](/docs/integrations/tools/huggingface_tools).
-
-```python
-from langchain_community.agent_toolkits.load_tools import load_huggingface_tool
-```

langchain_md_files/integrations/platforms/microsoft.mdx

@@ -1,561 +0,0 @@
----
-keywords: [azure]
----
-
-# Microsoft
-
-All functionality related to `Microsoft Azure` and other `Microsoft` products.
-
-## Chat Models
-
-### Azure OpenAI
-
->[Microsoft Azure](https://en.wikipedia.org/wiki/Microsoft_Azure), often referred to as `Azure` is a cloud computing platform run by `Microsoft`, which offers access, management, and development of applications and services through global data centers. It provides a range of capabilities, including software as a service (SaaS), platform as a service (PaaS), and infrastructure as a service (IaaS). `Microsoft Azure` supports many programming languages, tools, and frameworks, including Microsoft-specific and third-party software and systems.
-
->[Azure OpenAI](https://learn.microsoft.com/en-us/azure/cognitive-services/openai/) is an `Azure` service with powerful language models from `OpenAI` including the `GPT-3`, `Codex` and `Embeddings model` series for content generation, summarization, semantic search, and natural language to code translation.
-
-```bash
-pip install langchain-openai
-```
-
-Set the environment variables to get access to the `Azure OpenAI` service.
-
-```python
-import os
-
-os.environ["AZURE_OPENAI_ENDPOINT"] = "https://<your-endpoint.openai.azure.com/"
-os.environ["AZURE_OPENAI_API_KEY"] = "your AzureOpenAI key"
-```
-
-See a [usage example](/docs/integrations/chat/azure_chat_openai)
-
-
-```python
-from langchain_openai import AzureChatOpenAI
-```
-
-### Azure ML Chat Online Endpoint
-
-See the documentation [here](/docs/integrations/chat/azureml_chat_endpoint) for accessing chat
-models hosted with [Azure Machine Learning](https://azure.microsoft.com/en-us/products/machine-learning/).
-
-
-## LLMs
-
-### Azure ML
-
-See a [usage example](/docs/integrations/llms/azure_ml).
-
-```python
-from langchain_community.llms.azureml_endpoint import AzureMLOnlineEndpoint
-```
-
-### Azure OpenAI
-
-See a [usage example](/docs/integrations/llms/azure_openai).
-
-```python
-from langchain_openai import AzureOpenAI
-```
-
-## Embedding Models
-### Azure OpenAI
-
-See a [usage example](/docs/integrations/text_embedding/azureopenai)
-
-```python
-from langchain_openai import AzureOpenAIEmbeddings
-```
-
-## Document loaders
-
-### Azure AI Data
-
->[Azure AI Studio](https://ai.azure.com/) provides the capability to upload data assets 
-> to cloud storage and register existing data assets from the following sources:
->
->- `Microsoft OneLake`
->- `Azure Blob Storage`
->- `Azure Data Lake gen 2`
-
-First, you need to install several python packages.
-
-```bash
-pip install azureml-fsspec, azure-ai-generative
-```
-
-See a [usage example](/docs/integrations/document_loaders/azure_ai_data).
-
-```python
-from langchain.document_loaders import AzureAIDataLoader
-```
-
-
-### Azure AI Document Intelligence
-
->[Azure AI Document Intelligence](https://aka.ms/doc-intelligence) (formerly known
-> as `Azure Form Recognizer`) is machine-learning
-> based service that extracts texts (including handwriting), tables, document structures, 
-> and key-value-pairs
-> from digital or scanned PDFs, images, Office and HTML files.
->
-> Document Intelligence supports `PDF`, `JPEG/JPG`, `PNG`, `BMP`, `TIFF`, `HEIF`, `DOCX`, `XLSX`, `PPTX` and `HTML`.
-
-First, you need to install a python package.
-
-```bash
-pip install azure-ai-documentintelligence
-```
-
-See a [usage example](/docs/integrations/document_loaders/azure_document_intelligence).
-
-```python
-from langchain.document_loaders import AzureAIDocumentIntelligenceLoader
-```
-
-
-### Azure Blob Storage
-
->[Azure Blob Storage](https://learn.microsoft.com/en-us/azure/storage/blobs/storage-blobs-introduction) is Microsoft's object storage solution for the cloud. Blob Storage is optimized for storing massive amounts of unstructured data. Unstructured data is data that doesn't adhere to a particular data model or definition, such as text or binary data.
-
->[Azure Files](https://learn.microsoft.com/en-us/azure/storage/files/storage-files-introduction) offers fully managed
-> file shares in the cloud that are accessible via the industry standard Server Message Block (`SMB`) protocol,
-> Network File System (`NFS`) protocol, and `Azure Files REST API`. `Azure Files` are based on the `Azure Blob Storage`.
-
-`Azure Blob Storage` is designed for:
-- Serving images or documents directly to a browser.
-- Storing files for distributed access.
-- Streaming video and audio.
-- Writing to log files.
-- Storing data for backup and restore, disaster recovery, and archiving.
-- Storing data for analysis by an on-premises or Azure-hosted service.
-
-```bash
-pip install azure-storage-blob
-```
-
-See a [usage example for the Azure Blob Storage](/docs/integrations/document_loaders/azure_blob_storage_container).
-
-```python
-from langchain_community.document_loaders import AzureBlobStorageContainerLoader
-```
-
-See a [usage example for the Azure Files](/docs/integrations/document_loaders/azure_blob_storage_file).
-
-```python
-from langchain_community.document_loaders import AzureBlobStorageFileLoader
-```
-
-
-### Microsoft OneDrive
-
->[Microsoft OneDrive](https://en.wikipedia.org/wiki/OneDrive) (formerly `SkyDrive`) is a file-hosting service operated by Microsoft.
-
-First, you need to install a python package.
-
-```bash
-pip install o365
-```
-
-See a [usage example](/docs/integrations/document_loaders/microsoft_onedrive).
-
-```python
-from langchain_community.document_loaders import OneDriveLoader
-```
-
-### Microsoft OneDrive File
-
->[Microsoft OneDrive](https://en.wikipedia.org/wiki/OneDrive) (formerly `SkyDrive`) is a file-hosting service operated by Microsoft.
-
-First, you need to install a python package.
-
-```bash
-pip install o365
-```
-
-```python
-from langchain_community.document_loaders import OneDriveFileLoader
-```
-
-
-### Microsoft Word
-
->[Microsoft Word](https://www.microsoft.com/en-us/microsoft-365/word) is a word processor developed by Microsoft.
-
-See a [usage example](/docs/integrations/document_loaders/microsoft_word).
-
-```python
-from langchain_community.document_loaders import UnstructuredWordDocumentLoader
-```
-
-
-### Microsoft Excel
-
->[Microsoft Excel](https://en.wikipedia.org/wiki/Microsoft_Excel) is a spreadsheet editor developed by 
-> Microsoft for Windows, macOS, Android, iOS and iPadOS. 
-> It features calculation or computation capabilities, graphing tools, pivot tables, and a macro programming 
-> language called Visual Basic for Applications (VBA). Excel forms part of the Microsoft 365 suite of software.
-
-The `UnstructuredExcelLoader` is used to load `Microsoft Excel` files. The loader works with both `.xlsx` and `.xls` files. 
-The page content will be the raw text of the Excel file. If you use the loader in `"elements"` mode, an HTML 
-representation of the Excel file will be available in the document metadata under the `text_as_html` key.
-
-See a [usage example](/docs/integrations/document_loaders/microsoft_excel).
-
-```python
-from langchain_community.document_loaders import UnstructuredExcelLoader
-```
-
-
-### Microsoft SharePoint
-
->[Microsoft SharePoint](https://en.wikipedia.org/wiki/SharePoint) is a website-based collaboration system 
-> that uses workflow applications, “list” databases, and other web parts and security features to 
-> empower business teams to work together developed by Microsoft.
-
-See a [usage example](/docs/integrations/document_loaders/microsoft_sharepoint).
-
-```python
-from langchain_community.document_loaders.sharepoint import SharePointLoader
-```
-
-
-### Microsoft PowerPoint
-
->[Microsoft PowerPoint](https://en.wikipedia.org/wiki/Microsoft_PowerPoint) is a presentation program by Microsoft.
-
-See a [usage example](/docs/integrations/document_loaders/microsoft_powerpoint).
-
-```python
-from langchain_community.document_loaders import UnstructuredPowerPointLoader
-```
-
-### Microsoft OneNote
-
-First, let's install dependencies:
-
-```bash
-pip install bs4 msal
-```
-
-See a [usage example](/docs/integrations/document_loaders/microsoft_onenote).
-
-```python
-from langchain_community.document_loaders.onenote import OneNoteLoader
-```
-
-### Playwright URL Loader
-
->[Playwright](https://github.com/microsoft/playwright) is an open-source automation tool 
-> developed by `Microsoft` that allows you to programmatically control and automate 
-> web browsers. It is designed for end-to-end testing, scraping, and automating 
-> tasks across various web browsers such as `Chromium`, `Firefox`, and `WebKit`.
-
-
-First, let's install dependencies:
-
-```bash
-pip install playwright unstructured
-```
-
-See a [usage example](/docs/integrations/document_loaders/url/#playwright-url-loader).
-
-```python
-from langchain_community.document_loaders.onenote import OneNoteLoader
-```
-
-## AI Agent Memory System
-
-[AI agent](https://learn.microsoft.com/en-us/azure/cosmos-db/ai-agents) needs robust memory systems that support multi-modality, offer strong operational performance, and enable agent memory sharing as well as separation.
-
-### Azure Cosmos DB
-AI agents can rely on Azure Cosmos DB as a unified [memory system](https://learn.microsoft.com/en-us/azure/cosmos-db/ai-agents#memory-can-make-or-break-agents) solution, enjoying speed, scale, and simplicity. This service successfully [enabled OpenAI's ChatGPT service](https://www.youtube.com/watch?v=6IIUtEFKJec&t) to scale dynamically with high reliability and low maintenance. Powered by an atom-record-sequence engine, it is the world's first globally distributed [NoSQL](https://learn.microsoft.com/en-us/azure/cosmos-db/distributed-nosql), [relational](https://learn.microsoft.com/en-us/azure/cosmos-db/distributed-relational), and [vector database](https://learn.microsoft.com/en-us/azure/cosmos-db/vector-database) service that offers a serverless mode. 
-
-Below are two available Azure Cosmos DB APIs that can provide vector store functionalities.
-
-### Azure Cosmos DB for MongoDB (vCore)
-
->[Azure Cosmos DB for MongoDB vCore](https://learn.microsoft.com/en-us/azure/cosmos-db/mongodb/vcore/) makes it easy to create a database with full native MongoDB support.
-> You can apply your MongoDB experience and continue to use your favorite MongoDB drivers, SDKs, and tools by pointing your application to the API for MongoDB vCore account's connection string.
-> Use vector search in Azure Cosmos DB for MongoDB vCore to seamlessly integrate your AI-based applications with your data that's stored in Azure Cosmos DB.
-
-#### Installation and Setup
-
-See [detail configuration instructions](/docs/integrations/vectorstores/azure_cosmos_db).
-
-We need to install `pymongo` python package.
-
-```bash
-pip install pymongo
-```
-
-#### Deploy Azure Cosmos DB on Microsoft Azure
-
-Azure Cosmos DB for MongoDB vCore provides developers with a fully managed MongoDB-compatible database service for building modern applications with a familiar architecture.
-
-With Cosmos DB for MongoDB vCore, developers can enjoy the benefits of native Azure integrations, low total cost of ownership (TCO), and the familiar vCore architecture when migrating existing applications or building new ones.
-
-[Sign Up](https://azure.microsoft.com/en-us/free/) for free to get started today.
-
-See a [usage example](/docs/integrations/vectorstores/azure_cosmos_db).
-
-```python
-from langchain_community.vectorstores import AzureCosmosDBVectorSearch
-```
-
-### Azure Cosmos DB NoSQL
-
->[Azure Cosmos DB for NoSQL](https://learn.microsoft.com/en-us/azure/cosmos-db/nosql/vector-search) now offers vector indexing and search in preview.
-This feature is designed to handle high-dimensional vectors, enabling efficient and accurate vector search at any scale. You can now store vectors
-directly in the documents alongside your data. This means that each document in your database can contain not only traditional schema-free data,
-but also high-dimensional vectors as other properties of the documents. This colocation of data and vectors allows for efficient indexing and searching,
-as the vectors are stored in the same logical unit as the data they represent. This simplifies data management, AI application architectures, and the
-efficiency of vector-based operations.
-
-#### Installation and Setup
-
-See [detail configuration instructions](/docs/integrations/vectorstores/azure_cosmos_db_no_sql).
-
-We need to install `azure-cosmos` python package.
-
-```bash
-pip install azure-cosmos
-```
-
-#### Deploy Azure Cosmos DB on Microsoft Azure
-
-Azure Cosmos DB offers a solution for modern apps and intelligent workloads by being very responsive with dynamic and elastic autoscale. It is available
-in every Azure region and can automatically replicate data closer to users. It has SLA guaranteed low-latency and high availability.
-
-[Sign Up](https://learn.microsoft.com/en-us/azure/cosmos-db/nosql/quickstart-python?pivots=devcontainer-codespace) for free to get started today.
-
-See a [usage example](/docs/integrations/vectorstores/azure_cosmos_db_no_sql).
-
-```python
-from langchain_community.vectorstores import AzureCosmosDBNoSQLVectorSearch
-```
-
-### Azure Database for PostgreSQL
->[Azure Database for PostgreSQL - Flexible Server](https://learn.microsoft.com/en-us/azure/postgresql/flexible-server/service-overview) is a relational database service based on the open-source Postgres database engine. It's a fully managed database-as-a-service that can handle mission-critical workloads with predictable performance, security, high availability, and dynamic scalability.
-
-See [set up instructions](https://learn.microsoft.com/en-us/azure/postgresql/flexible-server/quickstart-create-server-portal) for Azure Database for PostgreSQL. 
-
-See a [usage example](/docs/integrations/memory/postgres_chat_message_history/). Simply use the [connection string](https://learn.microsoft.com/en-us/azure/postgresql/flexible-server/connect-python?tabs=cmd%2Cpassword#add-authentication-code) from your Azure Portal. 
-
-Since Azure Database for PostgreSQL is open-source Postgres, you can use the [LangChain's Postgres support](/docs/integrations/vectorstores/pgvector/) to connect to Azure Database for PostgreSQL.
-
-
-### Azure AI Search
-
-[Azure AI Search](https://learn.microsoft.com/azure/search/search-what-is-azure-search) is a cloud search service
-that gives developers infrastructure, APIs, and tools for information retrieval of vector, keyword, and hybrid
-queries at scale. See [here](/docs/integrations/vectorstores/azuresearch) for usage examples.
-
-```python
-from langchain_community.vectorstores.azuresearch import AzureSearch
-```
-
-## Retrievers
-
-### Azure AI Search
-
->[Azure AI Search](https://learn.microsoft.com/en-us/azure/search/search-what-is-azure-search) (formerly known as `Azure Search` or `Azure Cognitive Search` ) is a cloud search service that gives developers infrastructure, APIs, and tools for building a rich search experience over private, heterogeneous content in web, mobile, and enterprise applications.
-
->Search is foundational to any app that surfaces text to users, where common scenarios include catalog or document search, online retail apps, or data exploration over proprietary content. When you create a search service, you'll work with the following capabilities:
->- A search engine for full text search over a search index containing user-owned content
->- Rich indexing, with lexical analysis and optional AI enrichment for content extraction and transformation
->- Rich query syntax for text search, fuzzy search, autocomplete, geo-search and more
->- Programmability through REST APIs and client libraries in Azure SDKs
->- Azure integration at the data layer, machine learning layer, and AI (AI Services)
-
-See [set up instructions](https://learn.microsoft.com/en-us/azure/search/search-create-service-portal).
-
-See a [usage example](/docs/integrations/retrievers/azure_ai_search).
-
-```python
-from langchain_community.retrievers import AzureAISearchRetriever
-```
-
-## Vector Store
-### Azure Database for PostgreSQL
->[Azure Database for PostgreSQL - Flexible Server](https://learn.microsoft.com/en-us/azure/postgresql/flexible-server/service-overview) is a relational database service based on the open-source Postgres database engine. It's a fully managed database-as-a-service that can handle mission-critical workloads with predictable performance, security, high availability, and dynamic scalability.
-
-See [set up instructions](https://learn.microsoft.com/en-us/azure/postgresql/flexible-server/quickstart-create-server-portal) for Azure Database for PostgreSQL. 
-
-You need to [enable pgvector extension](https://learn.microsoft.com/en-us/azure/postgresql/flexible-server/how-to-use-pgvector) in your database to use Postgres as a vector store. Once you have the extension enabled, you can use the [PGVector in LangChain](/docs/integrations/vectorstores/pgvector/) to connect to Azure Database for PostgreSQL. 
-
-See a [usage example](/docs/integrations/vectorstores/pgvector/). Simply use the [connection string](https://learn.microsoft.com/en-us/azure/postgresql/flexible-server/connect-python?tabs=cmd%2Cpassword#add-authentication-code) from your Azure Portal. 
-
-
-## Tools
-
-### Azure Container Apps dynamic sessions
-
-We need to get the `POOL_MANAGEMENT_ENDPOINT` environment variable from the Azure Container Apps service.
-See the instructions [here](/docs/integrations/tools/azure_dynamic_sessions/#setup).
-
-We need to install a python package.
-
-```bash
-pip install langchain-azure-dynamic-sessions
-```
-
-See a [usage example](/docs/integrations/tools/azure_dynamic_sessions).
-
-```python
-from langchain_azure_dynamic_sessions import SessionsPythonREPLTool
-```
-
-### Bing Search
-
-Follow the documentation [here](/docs/integrations/tools/bing_search) to get a detail explanations and instructions of this tool.
-
-The environment variable `BING_SUBSCRIPTION_KEY` and `BING_SEARCH_URL` are required from Bing Search resource.
-
-```python
-from langchain_community.tools.bing_search import BingSearchResults
-from langchain_community.utilities import BingSearchAPIWrapper
-
-api_wrapper = BingSearchAPIWrapper()
-tool = BingSearchResults(api_wrapper=api_wrapper)
-```
-
-## Toolkits
-
-### Azure AI Services
-
-We need to install several python packages.
-
-```bash
-pip install azure-ai-formrecognizer azure-cognitiveservices-speech azure-ai-vision-imageanalysis
-```
-
-See a [usage example](/docs/integrations/tools/azure_ai_services).
-
-```python
-from langchain_community.agent_toolkits import azure_ai_services
-```
-
-The `azure_ai_services` toolkit includes the following tools:
-
-- Image Analysis: [AzureAiServicesImageAnalysisTool](https://python.langchain.com/v0.2/api_reference/community/tools/langchain_community.tools.azure_ai_services.image_analysis.AzureAiServicesImageAnalysisTool.html)
-- Document Intelligence: [AzureAiServicesDocumentIntelligenceTool](https://python.langchain.com/v0.2/api_reference/community/tools/langchain_community.tools.azure_ai_services.document_intelligence.AzureAiServicesDocumentIntelligenceTool.html)
-- Speech to Text: [AzureAiServicesSpeechToTextTool](https://python.langchain.com/v0.2/api_reference/community/tools/langchain_community.tools.azure_ai_services.speech_to_text.AzureAiServicesSpeechToTextTool.html)
-- Text to Speech: [AzureAiServicesTextToSpeechTool](https://python.langchain.com/v0.2/api_reference/community/tools/langchain_community.tools.azure_ai_services.text_to_speech.AzureAiServicesTextToSpeechTool.html)
-- Text Analytics for Health: [AzureAiServicesTextAnalyticsForHealthTool](https://python.langchain.com/v0.2/api_reference/community/tools/langchain_community.tools.azure_ai_services.text_analytics_for_health.AzureAiServicesTextAnalyticsForHealthTool.html)
-
-
-### Microsoft Office 365 email and calendar
-
-We need to install `O365` python package.
-
-```bash
-pip install O365
-```
-
-
-See a [usage example](/docs/integrations/tools/office365).
-
-```python
-from langchain_community.agent_toolkits import O365Toolkit
-```
-
-### Microsoft Azure PowerBI
-
-We need to install `azure-identity` python package.
-
-```bash
-pip install azure-identity
-```
-
-See a [usage example](/docs/integrations/tools/powerbi).
-
-```python
-from langchain_community.agent_toolkits import PowerBIToolkit
-from langchain_community.utilities.powerbi import PowerBIDataset
-```
-
-### PlayWright Browser Toolkit
-
->[Playwright](https://github.com/microsoft/playwright) is an open-source automation tool 
-> developed by `Microsoft` that allows you to programmatically control and automate 
-> web browsers. It is designed for end-to-end testing, scraping, and automating 
-> tasks across various web browsers such as `Chromium`, `Firefox`, and `WebKit`.
-
-We need to install several python packages.
-
-```bash
-pip install playwright lxml
-```
-
-See a [usage example](/docs/integrations/tools/playwright).
-
-```python
-from langchain_community.agent_toolkits import PlayWrightBrowserToolkit
-```
-
-#### PlayWright Browser individual tools
-
-You can use individual tools from the PlayWright Browser Toolkit.
-
-```python
-from langchain_community.tools.playwright import ClickTool
-from langchain_community.tools.playwright import CurrentWebPageTool
-from langchain_community.tools.playwright import ExtractHyperlinksTool
-from langchain_community.tools.playwright import ExtractTextTool
-from langchain_community.tools.playwright import GetElementsTool
-from langchain_community.tools.playwright import NavigateTool
-from langchain_community.tools.playwright import NavigateBackTool
-```
-
-## Graphs
-
-### Azure Cosmos DB for Apache Gremlin
-
-We need to install a python package.
-
-```bash
-pip install gremlinpython
-```
-
-See a [usage example](/docs/integrations/graphs/azure_cosmosdb_gremlin).
-
-```python
-from langchain_community.graphs import GremlinGraph
-from langchain_community.graphs.graph_document import GraphDocument, Node, Relationship
-```
-
-## Utilities
-
-### Bing Search API
-
->[Microsoft Bing](https://www.bing.com/), commonly referred to as `Bing` or `Bing Search`, 
-> is a web search engine owned and operated by `Microsoft`.
-
-See a [usage example](/docs/integrations/tools/bing_search).
-
-```python
-from langchain_community.utilities import BingSearchAPIWrapper
-```
-
-## More
-
-### Microsoft Presidio
-
->[Presidio](https://microsoft.github.io/presidio/) (Origin from Latin praesidium ‘protection, garrison’) 
-> helps to ensure sensitive data is properly managed and governed. It provides fast identification and 
-> anonymization modules for private entities in text and images such as credit card numbers, names, 
-> locations, social security numbers, bitcoin wallets, US phone numbers, financial data and more.
-
-First, you need to install several python packages and download a `SpaCy` model.
-
-```bash
-pip install langchain-experimental openai presidio-analyzer presidio-anonymizer spacy Faker
-python -m spacy download en_core_web_lg
-```
-
-See [usage examples](https://python.langchain.com/v0.1/docs/guides/productionization/safety/presidio_data_anonymization).
-
-```python
-from langchain_experimental.data_anonymizer import PresidioAnonymizer, PresidioReversibleAnonymizer
-```

langchain_md_files/integrations/platforms/openai.mdx

@@ -1,123 +0,0 @@
----
-keywords: [openai]
----
-
-# OpenAI
-
-All functionality related to OpenAI
-
->[OpenAI](https://en.wikipedia.org/wiki/OpenAI) is American artificial intelligence (AI) research laboratory 
-> consisting of the non-profit `OpenAI Incorporated`
-> and its for-profit subsidiary corporation `OpenAI Limited Partnership`. 
-> `OpenAI` conducts AI research with the declared intention of promoting and developing a friendly AI. 
-> `OpenAI` systems run on an `Azure`-based supercomputing platform from `Microsoft`.
-
->The [OpenAI API](https://platform.openai.com/docs/models) is powered by a diverse set of models with different capabilities and price points.
-> 
->[ChatGPT](https://chat.openai.com) is the Artificial Intelligence (AI) chatbot developed by `OpenAI`.
-
-## Installation and Setup
-
-Install the integration package with
-```bash
-pip install langchain-openai
-```
-
-Get an OpenAI api key and set it as an environment variable (`OPENAI_API_KEY`)
-
-## Chat model
-
-See a [usage example](/docs/integrations/chat/openai).
-
-```python
-from langchain_openai import ChatOpenAI
-```
-
-If you are using a model hosted on `Azure`, you should use different wrapper for that:
-```python
-from langchain_openai import AzureChatOpenAI
-```
-For a more detailed walkthrough of the `Azure` wrapper, see [here](/docs/integrations/chat/azure_chat_openai).
-
-## LLM
-
-See a [usage example](/docs/integrations/llms/openai).
-
-```python
-from langchain_openai import OpenAI
-```
-
-If you are using a model hosted on `Azure`, you should use different wrapper for that:
-```python
-from langchain_openai import AzureOpenAI
-```
-For a more detailed walkthrough of the `Azure` wrapper, see [here](/docs/integrations/llms/azure_openai).
-
-## Embedding Model
-
-See a [usage example](/docs/integrations/text_embedding/openai)
-
-```python
-from langchain_openai import OpenAIEmbeddings
-```
-
-## Document Loader
-
-See a [usage example](/docs/integrations/document_loaders/chatgpt_loader).
-
-```python
-from langchain_community.document_loaders.chatgpt import ChatGPTLoader
-```
-
-## Retriever
-
-See a [usage example](/docs/integrations/retrievers/chatgpt-plugin).
-
-```python
-from langchain.retrievers import ChatGPTPluginRetriever
-```
-
-## Tools
-
-### Dall-E Image Generator
-
->[OpenAI Dall-E](https://openai.com/dall-e-3) are text-to-image models developed by `OpenAI` 
-> using deep learning methodologies to generate digital images from natural language descriptions, 
-> called "prompts".
-
-
-See a [usage example](/docs/integrations/tools/dalle_image_generator).
-
-```python
-from langchain_community.utilities.dalle_image_generator import DallEAPIWrapper
-```
-
-## Adapter
-
-See a [usage example](/docs/integrations/adapters/openai).
-
-```python
-from langchain.adapters import openai as lc_openai
-```
-
-## Tokenizer
-
-There are several places you can use the `tiktoken` tokenizer. By default, it is used to count tokens
-for OpenAI LLMs.
-
-You can also use it to count tokens when splitting documents with 
-```python
-from langchain.text_splitter import CharacterTextSplitter
-CharacterTextSplitter.from_tiktoken_encoder(...)
-```
-For a more detailed walkthrough of this, see [this notebook](/docs/how_to/split_by_token/#tiktoken)
-
-## Chain
-
-See a [usage example](https://python.langchain.com/v0.1/docs/guides/productionization/safety/moderation).
-
-```python
-from langchain.chains import OpenAIModerationChain
-```
-
-

langchain_md_files/integrations/providers/acreom.mdx

@@ -1,15 +0,0 @@
-# Acreom
-
-[acreom](https://acreom.com) is a dev-first knowledge base with tasks running on local `markdown` files.
-
-## Installation and Setup
-
-No installation is required. 
-
-## Document Loader
-
-See a [usage example](/docs/integrations/document_loaders/acreom).
-
-```python
-from langchain_community.document_loaders import AcreomLoader
-```

langchain_md_files/integrations/providers/activeloop_deeplake.mdx

@@ -1,38 +0,0 @@
-# Activeloop Deep Lake
-
->[Activeloop Deep Lake](https://docs.activeloop.ai/) is a data lake for Deep Learning applications, allowing you to use it 
-> as a vector store.
-
-## Why Deep Lake?
-
-- More than just a (multi-modal) vector store. You can later use the dataset to fine-tune your own LLM models.
-- Not only stores embeddings, but also the original data with automatic version control.
-- Truly serverless. Doesn't require another service and can be used with major cloud providers (`AWS S3`, `GCS`, etc.)
-
-`Activeloop Deep Lake` supports `SelfQuery Retrieval`:
-[Activeloop Deep Lake Self Query Retrieval](/docs/integrations/retrievers/self_query/activeloop_deeplake_self_query)
-
-
-## More Resources
-
-1. [Ultimate Guide to LangChain & Deep Lake: Build ChatGPT to Answer Questions on Your Financial Data](https://www.activeloop.ai/resources/ultimate-guide-to-lang-chain-deep-lake-build-chat-gpt-to-answer-questions-on-your-financial-data/)
-2. [Twitter the-algorithm codebase analysis with Deep Lake](https://github.com/langchain-ai/langchain/blob/master/cookbook/twitter-the-algorithm-analysis-deeplake.ipynb)
-3. Here is [whitepaper](https://www.deeplake.ai/whitepaper) and [academic paper](https://arxiv.org/pdf/2209.10785.pdf) for Deep Lake
-4. Here is a set of additional resources available for review: [Deep Lake](https://github.com/activeloopai/deeplake), [Get started](https://docs.activeloop.ai/getting-started) and [Tutorials](https://docs.activeloop.ai/hub-tutorials)
-
-## Installation and Setup
-
-Install the Python package:
-
-```bash
-pip install deeplake
-```
-
-
-## VectorStore
-
-```python
-from langchain_community.vectorstores import DeepLake
-```
-
-See a [usage example](/docs/integrations/vectorstores/activeloop_deeplake).

langchain_md_files/integrations/providers/ai21.mdx

@@ -1,67 +0,0 @@
-# AI21 Labs
-
->[AI21 Labs](https://www.ai21.com/about) is a company specializing in Natural 
-> Language Processing (NLP), which develops AI systems 
-> that can understand and generate natural language.
-
-This page covers how to use the `AI21` ecosystem within `LangChain`.
-
-## Installation and Setup
-
-- Get an AI21 api key and set it as an environment variable (`AI21_API_KEY`)
-- Install the Python package:
-
-```bash
-pip install langchain-ai21
-```
-
-## LLMs
-
-See a [usage example](/docs/integrations/llms/ai21).
-
-### AI21 LLM
-
-```python
-from langchain_ai21 import AI21LLM
-```
-
-### AI21 Contextual Answer
-
-You can use AI21’s contextual answers model to receive text or document, 
-serving as a context, and a question and return an answer based entirely on this context.
-
-```python
-from langchain_ai21 import AI21ContextualAnswers
-```
-
-
-## Chat models
-
-### AI21 Chat 
-
-See a [usage example](/docs/integrations/chat/ai21).
-
-```python
-from langchain_ai21 import ChatAI21
-```
-
-## Embedding models
-
-### AI21 Embeddings
-
-See a [usage example](/docs/integrations/text_embedding/ai21).
-
-```python
-from langchain_ai21 import AI21Embeddings
-```
-
-## Text splitters
-
-### AI21 Semantic Text Splitter
-
-See a [usage example](/docs/integrations/document_transformers/ai21_semantic_text_splitter).
-
-```python
-from langchain_ai21 import AI21SemanticTextSplitter
-```
-

langchain_md_files/integrations/providers/ainetwork.mdx

@@ -1,23 +0,0 @@
-# AINetwork
-
->[AI Network](https://www.ainetwork.ai/build-on-ain) is a layer 1 blockchain designed to accommodate 
-> large-scale AI models, utilizing a decentralized GPU network powered by the 
-> [$AIN token](https://www.ainetwork.ai/token), enriching AI-driven `NFTs` (`AINFTs`).
-
-
-## Installation and Setup
-
-You need to install `ain-py` python package.
-
-```bash
-pip install ain-py
-```
-You need to set the `AIN_BLOCKCHAIN_ACCOUNT_PRIVATE_KEY` environmental variable to your AIN Blockchain Account Private Key.
-## Toolkit
-
-See a [usage example](/docs/integrations/tools/ainetwork).
-
-```python
-from langchain_community.agent_toolkits.ainetwork.toolkit import AINetworkToolkit
-```
-

langchain_md_files/integrations/providers/airbyte.mdx

@@ -1,32 +0,0 @@
-# Airbyte
-
->[Airbyte](https://github.com/airbytehq/airbyte) is a data integration platform for ELT pipelines from APIs, 
-> databases & files to warehouses & lakes. It has the largest catalog of ELT connectors to data warehouses and databases.
-
-## Installation and Setup
-
-```bash
-pip install -U langchain-airbyte
-```
-
-:::note
-
-Currently, the `langchain-airbyte` library does not support Pydantic v2.
-Please downgrade to Pydantic v1 to use this package.
-
-This package also currently requires Python 3.10+.
-
-:::
-
-The integration package doesn't require any global environment variables that need to be
-set, but some integrations (e.g. `source-github`) may need credentials passed in.
-
-## Document loader
-
-### AirbyteLoader
-
-See a [usage example](/docs/integrations/document_loaders/airbyte).
-
-```python
-from langchain_airbyte import AirbyteLoader
-```

langchain_md_files/integrations/providers/alchemy.mdx

@@ -1,20 +0,0 @@
-# Alchemy
-
->[Alchemy](https://www.alchemy.com) is the platform to build blockchain applications.
-
-## Installation and Setup
-
-Check out the [installation guide](/docs/integrations/document_loaders/blockchain).
-
-## Document loader
-
-### BlockchainLoader on the Alchemy platform
-
-See a [usage example](/docs/integrations/document_loaders/blockchain).
-
-```python
-from langchain_community.document_loaders.blockchain import (
-    BlockchainDocumentLoader,
-    BlockchainType,
-)
-```

langchain_md_files/integrations/providers/aleph_alpha.mdx

@@ -1,36 +0,0 @@
-# Aleph Alpha
-
->[Aleph Alpha](https://docs.aleph-alpha.com/) was founded in 2019 with the mission to research and build the foundational technology for an era of strong AI. The team of international scientists, engineers, and innovators researches, develops, and deploys transformative AI like large language and multimodal models and runs the fastest European commercial AI cluster.
-
->[The Luminous series](https://docs.aleph-alpha.com/docs/introduction/luminous/) is a family of large language models.
-
-## Installation and Setup
-
-```bash
-pip install aleph-alpha-client
-```
-
-You have to create a new token. Please, see [instructions](https://docs.aleph-alpha.com/docs/account/#create-a-new-token).
-
-```python
-from getpass import getpass
-
-ALEPH_ALPHA_API_KEY = getpass()
-```
-
-
-## LLM
-
-See a [usage example](/docs/integrations/llms/aleph_alpha).
-
-```python
-from langchain_community.llms import AlephAlpha
-```
-
-## Text Embedding Models
-
-See a [usage example](/docs/integrations/text_embedding/aleph_alpha).
-
-```python
-from langchain_community.embeddings import AlephAlphaSymmetricSemanticEmbedding, AlephAlphaAsymmetricSemanticEmbedding
-```

langchain_md_files/integrations/providers/alibaba_cloud.mdx

@@ -1,91 +0,0 @@
-# Alibaba Cloud
-
->[Alibaba Group Holding Limited (Wikipedia)](https://en.wikipedia.org/wiki/Alibaba_Group), or `Alibaba`
-> (Chinese: 阿里巴巴), is a Chinese multinational technology company specializing in e-commerce, retail, 
-> Internet, and technology.
-> 
-> [Alibaba Cloud (Wikipedia)](https://en.wikipedia.org/wiki/Alibaba_Cloud), also known as `Aliyun`
-> (Chinese: 阿里云; pinyin: Ālǐyún; lit. 'Ali Cloud'), is a cloud computing company, a subsidiary 
-> of `Alibaba Group`. `Alibaba Cloud` provides cloud computing services to online businesses and 
-> Alibaba's own e-commerce ecosystem.
- 
- 
-## LLMs
-
-### Alibaba Cloud PAI EAS
-
-See [installation instructions and a usage example](/docs/integrations/llms/alibabacloud_pai_eas_endpoint).
-
-```python
-from langchain_community.llms.pai_eas_endpoint import PaiEasEndpoint
-```
-
-### Tongyi Qwen
-
-See [installation instructions and a usage example](/docs/integrations/llms/tongyi).
-
-```python
-from langchain_community.llms import Tongyi
-```
-
-## Chat Models
-
-### Alibaba Cloud PAI EAS
-
-See [installation instructions and a usage example](/docs/integrations/chat/alibaba_cloud_pai_eas).
-
-```python
-from langchain_community.chat_models import PaiEasChatEndpoint
-```
-
-### Tongyi Qwen Chat
-
-See [installation instructions and a usage example](/docs/integrations/chat/tongyi).
-
-```python
-from langchain_community.chat_models.tongyi import ChatTongyi
-```
-
-## Document Loaders
-
-### Alibaba Cloud MaxCompute
-
-See [installation instructions and a usage example](/docs/integrations/document_loaders/alibaba_cloud_maxcompute).
-
-```python
-from langchain_community.document_loaders import MaxComputeLoader
-```
-
-## Vector stores
-
-### Alibaba Cloud OpenSearch
-
-See [installation instructions and a usage example](/docs/integrations/vectorstores/alibabacloud_opensearch).
-
-```python
-from langchain_community.vectorstores import AlibabaCloudOpenSearch, AlibabaCloudOpenSearchSettings
-```
-
-### Alibaba Cloud Tair
-
-See [installation instructions and a usage example](/docs/integrations/vectorstores/tair).
-
-```python
-from langchain_community.vectorstores import Tair
-```
-
-### AnalyticDB
-
-See [installation instructions and a usage example](/docs/integrations/vectorstores/analyticdb).
-
-```python
-from langchain_community.vectorstores import AnalyticDB
-```
-
-### Hologres
-
-See [installation instructions and a usage example](/docs/integrations/vectorstores/hologres).
-
-```python
-from langchain_community.vectorstores import Hologres
-```

langchain_md_files/integrations/providers/analyticdb.mdx

@@ -1,31 +0,0 @@
-# AnalyticDB
-
->[AnalyticDB for PostgreSQL](https://www.alibabacloud.com/help/en/analyticdb-for-postgresql/latest/product-introduction-overview) 
-> is a massively parallel processing (MPP) data warehousing service 
-> from [Alibaba Cloud](https://www.alibabacloud.com/)
->that is designed to analyze large volumes of data online.
-
->`AnalyticDB for PostgreSQL` is developed based on the open-source `Greenplum Database` 
-> project and is enhanced with in-depth extensions by `Alibaba Cloud`. AnalyticDB 
-> for PostgreSQL is compatible with the ANSI SQL 2003 syntax and the PostgreSQL and 
-> Oracle database ecosystems. AnalyticDB for PostgreSQL also supports row store and 
-> column store. AnalyticDB for PostgreSQL processes petabytes of data offline at a 
-> high performance level and supports highly concurrent.
-
-This page covers how to use the AnalyticDB ecosystem within LangChain.
-
-## Installation and Setup
-
-You need to install the `sqlalchemy` python package.
-
-```bash
-pip install sqlalchemy
-```
-
-## VectorStore
-
-See a [usage example](/docs/integrations/vectorstores/analyticdb).
-
-```python
-from langchain_community.vectorstores import AnalyticDB
-```

langchain_md_files/integrations/providers/annoy.mdx

@@ -1,21 +0,0 @@
-# Annoy
-
-> [Annoy](https://github.com/spotify/annoy) (`Approximate Nearest Neighbors Oh Yeah`) 
-> is a C++ library with Python bindings to search for points in space that are 
-> close to a given query point. It also creates large read-only file-based data 
-> structures that are mapped into memory so that many processes may share the same data. 
-
-## Installation and Setup
-
-```bash
-pip install annoy
-```
-
-
-## Vectorstore
-
-See a [usage example](/docs/integrations/vectorstores/annoy).
-
-```python
-from langchain_community.vectorstores import Annoy
-```

langchain_md_files/integrations/providers/anyscale.mdx

@@ -1,42 +0,0 @@
-# Anyscale
-
->[Anyscale](https://www.anyscale.com) is a platform to run, fine tune and scale LLMs via production-ready APIs.
-> [Anyscale Endpoints](https://docs.anyscale.com/endpoints/overview) serve many open-source models in a cost-effective way.
-
-`Anyscale` also provides [an example](https://docs.anyscale.com/endpoints/model-serving/examples/langchain-integration) 
-how to setup `LangChain` with `Anyscale` for advanced chat agents.
-
-## Installation and Setup
-
-- Get an Anyscale Service URL, route and API key and set them as environment variables (`ANYSCALE_SERVICE_URL`,`ANYSCALE_SERVICE_ROUTE`, `ANYSCALE_SERVICE_TOKEN`). 
-- Please see [the Anyscale docs](https://www.anyscale.com/get-started) for more details.
-
-We have to install the `openai` package:
-
-```bash
-pip install openai
-```
-
-## LLM
-
-See a [usage example](/docs/integrations/llms/anyscale).
-
-```python
-from langchain_community.llms.anyscale import Anyscale
-```
-
-## Chat Models
-
-See a [usage example](/docs/integrations/chat/anyscale).
-
-```python
-from langchain_community.chat_models.anyscale import ChatAnyscale
-```
-
-## Embeddings
-
-See a [usage example](/docs/integrations/text_embedding/anyscale).
-
-```python
-from langchain_community.embeddings import AnyscaleEmbeddings
-```

langchain_md_files/integrations/providers/apache_doris.mdx

@@ -1,22 +0,0 @@
-# Apache Doris
-
->[Apache Doris](https://doris.apache.org/) is a modern data warehouse for real-time analytics.
-It delivers lightning-fast analytics on real-time data at scale.
-
->Usually `Apache Doris` is categorized into OLAP, and it has showed excellent performance 
-> in [ClickBench — a Benchmark For Analytical DBMS](https://benchmark.clickhouse.com/). 
-> Since it has a super-fast vectorized execution engine, it could also be used as a fast vectordb.
-
-## Installation and Setup
-
-```bash
-pip install pymysql
-```
-
-## Vector Store
-
-See a [usage example](/docs/integrations/vectorstores/apache_doris).
-
-```python
-from langchain_community.vectorstores import ApacheDoris
-```

langchain_md_files/integrations/providers/apify.mdx

@@ -1,41 +0,0 @@
-# Apify
-
-
->[Apify](https://apify.com) is a cloud platform for web scraping and data extraction,
->which provides an [ecosystem](https://apify.com/store) of more than a thousand
->ready-made apps called *Actors* for various scraping, crawling, and extraction use cases.
-
-[![Apify Actors](/img/ApifyActors.png)](https://apify.com/store)
-
-This integration enables you run Actors on the `Apify` platform and load their results into LangChain to feed your vector
-indexes with documents and data from the web, e.g. to generate answers from websites with documentation,
-blogs, or knowledge bases.
-
-
-## Installation and Setup
-
-- Install the Apify API client for Python with `pip install apify-client`
-- Get your [Apify API token](https://console.apify.com/account/integrations) and either set it as
-  an environment variable (`APIFY_API_TOKEN`) or pass it to the `ApifyWrapper` as `apify_api_token` in the constructor.
-
-
-## Utility
-
-You can use the `ApifyWrapper` to run Actors on the Apify platform.
-
-```python
-from langchain_community.utilities import ApifyWrapper
-```
-
-For more information on this wrapper, see [the API reference](https://python.langchain.com/v0.2/api_reference/community/utilities/langchain_community.utilities.apify.ApifyWrapper.html).
-
-
-## Document loader
-
-You can also use our `ApifyDatasetLoader` to get data from Apify dataset.
-
-```python
-from langchain_community.document_loaders import ApifyDatasetLoader
-```
-
-For a more detailed walkthrough of this loader, see [this notebook](/docs/integrations/document_loaders/apify_dataset).

langchain_md_files/integrations/providers/arangodb.mdx

@@ -1,25 +0,0 @@
-# ArangoDB
-
->[ArangoDB](https://github.com/arangodb/arangodb) is a scalable graph database system to 
-> drive value from connected data, faster. Native graphs, an integrated search engine, and JSON support, via a single query language. ArangoDB runs on-prem, in the cloud – anywhere.
-
-## Installation and Setup
-
-Install the [ArangoDB Python Driver](https://github.com/ArangoDB-Community/python-arango) package with
-
-```bash
-pip install python-arango
-```
-
-## Graph QA Chain
-
-Connect your `ArangoDB` Database with a chat model to get insights on your data. 
-
-See the notebook example [here](/docs/integrations/graphs/arangodb).
-
-```python
-from arango import ArangoClient
-
-from langchain_community.graphs import ArangoGraph
-from langchain.chains import ArangoGraphQAChain
-```

langchain_md_files/integrations/providers/arcee.mdx

@@ -1,30 +0,0 @@
-# Arcee
-
->[Arcee](https://www.arcee.ai/about/about-us) enables the development and advancement 
-> of what we coin as SLMs—small, specialized, secure, and scalable language models. 
-> By offering a SLM Adaptation System and a seamless, secure integration, 
-> `Arcee` empowers enterprises to harness the full potential of 
-> domain-adapted language models, driving the transformative 
-> innovation in operations.
-
-
-## Installation and Setup
-
-Get your `Arcee API` key.
-
-
-## LLMs
-
-See a [usage example](/docs/integrations/llms/arcee).
-
-```python
-from langchain_community.llms import Arcee
-```
-
-## Retrievers
-
-See a [usage example](/docs/integrations/retrievers/arcee).
-
-```python
-from langchain_community.retrievers import ArceeRetriever
-```

langchain_md_files/integrations/providers/arcgis.mdx

@@ -1,27 +0,0 @@
-# ArcGIS
-
->[ArcGIS](https://www.esri.com/en-us/arcgis/about-arcgis/overview) is a family of client, 
-> server and online geographic information system software developed and maintained by [Esri](https://www.esri.com/).
-> 
->`ArcGISLoader` uses the `arcgis` package.
-> `arcgis` is a Python library for the vector and raster analysis, geocoding, map making, 
-> routing and directions. It administers, organizes and manages users, 
-> groups and information items in your GIS.
->It enables access to ready-to-use maps and curated geographic data from `Esri` 
-> and other authoritative sources, and works with your own data as well. 
-
-## Installation and Setup
-
-We have to install the `arcgis` package.
-
-```bash
-pip install -U arcgis
-```
-
-## Document Loader
-
-See a [usage example](/docs/integrations/document_loaders/arcgis).
-
-```python
-from langchain_community.document_loaders import ArcGISLoader
-```

langchain_md_files/integrations/providers/argilla.mdx

@@ -1,25 +0,0 @@
-# Argilla
-
->[Argilla](https://argilla.io/) is an open-source data curation platform for LLMs. 
-> Using `Argilla`, everyone can build robust language models through faster data curation 
-> using both human and machine feedback. `Argilla` provides support for each step in the MLOps cycle, 
-> from data labeling to model monitoring.
-
-## Installation and Setup
-
-Get your [API key](https://platform.openai.com/account/api-keys).
-
-Install the Python package:
-
-```bash
-pip install argilla
-```
-
-## Callbacks
-
-
-```python
-from langchain.callbacks import ArgillaCallbackHandler
-```
-
-See an [example](/docs/integrations/callbacks/argilla).

langchain_md_files/integrations/providers/arize.mdx

@@ -1,24 +0,0 @@
-# Arize
-
-[Arize](https://arize.com) is an AI observability and LLM evaluation platform that offers
-support for LangChain applications, providing detailed traces of input, embeddings, retrieval,
-functions, and output messages.
-
-
-## Installation and Setup
-
-First, you need to install `arize` python package.
-
-```bash
-pip install arize
-```
-
-Second, you need to set up your [Arize account](https://app.arize.com/auth/join)
-and get your  `API_KEY` or `SPACE_KEY`.
-
-
-## Callback handler
-
-```python
-from langchain_community.callbacks import ArizeCallbackHandler
-```

langchain_md_files/integrations/providers/arxiv.mdx

@@ -1,36 +0,0 @@
-# Arxiv
-
->[arXiv](https://arxiv.org/) is an open-access archive for 2 million scholarly articles in the fields of physics, 
-> mathematics, computer science, quantitative biology, quantitative finance, statistics, electrical engineering and 
-> systems science, and economics.
-
-
-## Installation and Setup
-
-First, you need to install `arxiv` python package.
-
-```bash
-pip install arxiv
-```
-
-Second, you need to install `PyMuPDF` python package which transforms PDF files downloaded from the `arxiv.org` site into the text format.
-
-```bash
-pip install pymupdf
-```
-
-## Document Loader
-
-See a [usage example](/docs/integrations/document_loaders/arxiv).
-
-```python
-from langchain_community.document_loaders import ArxivLoader
-```
-
-## Retriever
-
-See a [usage example](/docs/integrations/retrievers/arxiv).
-
-```python
-from langchain_community.retrievers import ArxivRetriever
-```

langchain_md_files/integrations/providers/ascend.mdx

@@ -1,24 +0,0 @@
-# Ascend
-
->[Ascend](https://https://www.hiascend.com/) is Natural Process Unit provide by Huawei
-
-This page covers how to use ascend NPU with LangChain.
-
-### Installation
-
-Install using torch-npu using:
-
-```bash
-pip install torch-npu
-```
-
-Please follow the installation instructions as specified below:
-* Install CANN as shown [here](https://www.hiascend.com/document/detail/zh/canncommercial/700/quickstart/quickstart/quickstart_18_0002.html).
-
-### Embedding Models
-
-See a [usage example](/docs/integrations/text_embedding/ascend).
-
-```python
-from langchain_community.embeddings import AscendEmbeddings
-```

langchain_md_files/integrations/providers/asknews.mdx

@@ -1,33 +0,0 @@
-# AskNews
-
-[AskNews](https://asknews.app/) enhances language models with up-to-date global or historical news
-by processing and indexing over 300,000 articles daily, providing prompt-optimized responses
-through a low-latency endpoint, and ensuring transparency and diversity in its news coverage.
-
-## Installation and Setup
-
-First, you need to install `asknews` python package.
-
-```bash
-pip install asknews
-```
-
-You also need to set our AskNews API credentials, which can be generated at 
-the [AskNews console](https://my.asknews.app/).
-
-
-## Retriever
-
-See a [usage example](/docs/integrations/retrievers/asknews).
-
-```python
-from langchain_community.retrievers import AskNewsRetriever
-```
-
-## Tool
-
-See a [usage example](/docs/integrations/tools/asknews).
-
-```python
-from langchain_community.tools.asknews import AskNewsSearch
-```

langchain_md_files/integrations/providers/assemblyai.mdx

@@ -1,42 +0,0 @@
-# AssemblyAI
-
->[AssemblyAI](https://www.assemblyai.com/) builds `Speech AI` models for tasks like 
-speech-to-text, speaker diarization, speech summarization, and more.
-> `AssemblyAI’s` Speech AI models include accurate speech-to-text for voice data 
-> (such as calls, virtual meetings, and podcasts), speaker detection, sentiment analysis, 
-> chapter detection, PII redaction.
- 
-
-
-## Installation and Setup
-
-Get your [API key](https://www.assemblyai.com/dashboard/signup).
-
-Install the `assemblyai` package.
-
-```bash
-pip install -U assemblyai
-```
-
-## Document Loader
-
-###  AssemblyAI Audio Transcript
-
-The `AssemblyAIAudioTranscriptLoader` transcribes audio files with the `AssemblyAI API` 
-and loads the transcribed text into documents.
-
-See a [usage example](/docs/integrations/document_loaders/assemblyai).
-
-```python
-from langchain_community.document_loaders import AssemblyAIAudioTranscriptLoader
-```
-
-###  AssemblyAI Audio Loader By Id
-
-The `AssemblyAIAudioLoaderById` uses the AssemblyAI API to get an existing 
-transcription and loads the transcribed text into one or more Documents, 
-depending on the specified format.
-
-```python
-from langchain_community.document_loaders import AssemblyAIAudioLoaderById
-```

langchain_md_files/integrations/providers/astradb.mdx

@@ -1,150 +0,0 @@
-# Astra DB
-
-> [DataStax Astra DB](https://docs.datastax.com/en/astra/home/astra.html) is a serverless 
-> vector-capable database built on `Apache Cassandra®`and made conveniently available
-> through an easy-to-use JSON API.
-
-See a [tutorial provided by DataStax](https://docs.datastax.com/en/astra/astra-db-vector/tutorials/chatbot.html).
-
-## Installation and Setup
-
-Install the following Python package:
-```bash
-pip install "langchain-astradb>=0.1.0"
-```
-
-Get the [connection secrets](https://docs.datastax.com/en/astra/astra-db-vector/get-started/quickstart.html).
-Set up the following environment variables:
-
-```python
-ASTRA_DB_APPLICATION_TOKEN="TOKEN"
-ASTRA_DB_API_ENDPOINT="API_ENDPOINT"
-```
-
-## Vector Store
-
-```python
-from langchain_astradb import AstraDBVectorStore
-
-vector_store = AstraDBVectorStore(
-    embedding=my_embedding,
-    collection_name="my_store",
-    api_endpoint=ASTRA_DB_API_ENDPOINT,
-    token=ASTRA_DB_APPLICATION_TOKEN,
-)
-```
-
-Learn more in the [example notebook](/docs/integrations/vectorstores/astradb).
-
-See the [example provided by DataStax](https://docs.datastax.com/en/astra/astra-db-vector/integrations/langchain.html).
-
-## Chat message history
-
-```python
-from langchain_astradb import AstraDBChatMessageHistory
-
-message_history = AstraDBChatMessageHistory(
-    session_id="test-session",
-    api_endpoint=ASTRA_DB_API_ENDPOINT,
-    token=ASTRA_DB_APPLICATION_TOKEN,
-)
-```
-
-See the [usage example](/docs/integrations/memory/astradb_chat_message_history#example).
-
-## LLM Cache
-
-```python
-from langchain.globals import set_llm_cache
-from langchain_astradb import AstraDBCache
-
-set_llm_cache(AstraDBCache(
-    api_endpoint=ASTRA_DB_API_ENDPOINT,
-    token=ASTRA_DB_APPLICATION_TOKEN,
-))
-```
-
-Learn more in the [example notebook](/docs/integrations/llm_caching#astra-db-caches) (scroll to the Astra DB section).
-
-
-## Semantic LLM Cache
-
-```python
-from langchain.globals import set_llm_cache
-from langchain_astradb import AstraDBSemanticCache
-
-set_llm_cache(AstraDBSemanticCache(
-    embedding=my_embedding,
-    api_endpoint=ASTRA_DB_API_ENDPOINT,
-    token=ASTRA_DB_APPLICATION_TOKEN,
-))
-```
-
-Learn more in the [example notebook](/docs/integrations/llm_caching#astra-db-caches) (scroll to the appropriate section).
-
-Learn more in the [example notebook](/docs/integrations/memory/astradb_chat_message_history).
-
-## Document loader
-
-```python
-from langchain_astradb import AstraDBLoader
-
-loader = AstraDBLoader(
-    collection_name="my_collection",
-    api_endpoint=ASTRA_DB_API_ENDPOINT,
-    token=ASTRA_DB_APPLICATION_TOKEN,
-)
-```
-
-Learn more in the [example notebook](/docs/integrations/document_loaders/astradb).
-
-## Self-querying retriever
-
-```python
-from langchain_astradb import AstraDBVectorStore
-from langchain.retrievers.self_query.base import SelfQueryRetriever
-
-vector_store = AstraDBVectorStore(
-    embedding=my_embedding,
-    collection_name="my_store",
-    api_endpoint=ASTRA_DB_API_ENDPOINT,
-    token=ASTRA_DB_APPLICATION_TOKEN,
-)
-
-retriever = SelfQueryRetriever.from_llm(
-    my_llm,
-    vector_store,
-    document_content_description,
-    metadata_field_info
-)
-```
-
-Learn more in the [example notebook](/docs/integrations/retrievers/self_query/astradb).
-
-## Store
-
-```python
-from langchain_astradb import AstraDBStore
-
-store = AstraDBStore(
-    collection_name="my_kv_store",
-    api_endpoint=ASTRA_DB_API_ENDPOINT,
-    token=ASTRA_DB_APPLICATION_TOKEN,
-)
-```
-
-Learn more in the [example notebook](/docs/integrations/stores/astradb#astradbstore).
-
-## Byte Store
-
-```python
-from langchain_astradb import AstraDBByteStore
-
-store = AstraDBByteStore(
-    collection_name="my_kv_store",
-    api_endpoint=ASTRA_DB_API_ENDPOINT,
-    token=ASTRA_DB_APPLICATION_TOKEN,
-)
-```
-
-Learn more in the [example notebook](/docs/integrations/stores/astradb#astradbbytestore).