866f914895d62abb7a8b0677ea47f2cef56460d295cdcc48e02e4a442023013f

langchain_md_files/integrations/providers/atlas.mdx

@@ -1,19 +0,0 @@
-# Atlas
-
->[Nomic Atlas](https://docs.nomic.ai/index.html) is a platform for interacting with both 
-> small and internet scale unstructured datasets.
-
-
-## Installation and Setup
-
-- Install the Python package with `pip install nomic`
-- `Nomic` is also included in langchains poetry extras `poetry install -E all`
-
-
-## VectorStore
-
-See a [usage example](/docs/integrations/vectorstores/atlas).
-
-```python
-from langchain_community.vectorstores import AtlasDB
-```

langchain_md_files/integrations/providers/azlyrics.mdx

@@ -1,16 +0,0 @@
-# AZLyrics
-
->[AZLyrics](https://www.azlyrics.com/) is a large, legal, every day growing collection of lyrics.
-
-## Installation and Setup
-
-There isn't any special setup for it.
-
-
-## Document Loader
-
-See a [usage example](/docs/integrations/document_loaders/azlyrics).
-
-```python
-from langchain_community.document_loaders import AZLyricsLoader
-```

langchain_md_files/integrations/providers/bagel.mdx

@@ -1,21 +0,0 @@
-# Bagel
-
-> [Bagel](https://www.bagel.net/) (`Open Vector Database for AI`), is like GitHub for AI data.
-It is a collaborative platform where users can create,
-share, and manage vector datasets. It can support private projects for independent developers,
-internal collaborations for enterprises, and public contributions for data DAOs.
-
-## Installation and Setup
-
-```bash
-pip install bagelML
-```
-
-
-## VectorStore
-
-See a [usage example](/docs/integrations/vectorstores/bagel).
-
-```python
-from langchain_community.vectorstores import Bagel
-```

langchain_md_files/integrations/providers/bageldb.mdx

@@ -1,21 +0,0 @@
-# BagelDB
-
-> [BagelDB](https://www.bageldb.ai/) (`Open Vector Database for AI`), is like GitHub for AI data.
-It is a collaborative platform where users can create,
-share, and manage vector datasets. It can support private projects for independent developers,
-internal collaborations for enterprises, and public contributions for data DAOs.
-
-## Installation and Setup
-
-```bash
-pip install betabageldb
-```
-
-
-## VectorStore
-
-See a [usage example](/docs/integrations/vectorstores/bageldb).
-
-```python
-from langchain_community.vectorstores import Bagel
-```

langchain_md_files/integrations/providers/baichuan.mdx

@@ -1,33 +0,0 @@
-# Baichuan
-
->[Baichuan Inc.](https://www.baichuan-ai.com/) is a Chinese startup in the era of AGI, 
-> dedicated to addressing fundamental human needs: Efficiency, Health, and Happiness.
-
-
-## Installation and Setup
-
-Register and get an API key [here](https://platform.baichuan-ai.com/).
-
-## LLMs
-
-See a [usage example](/docs/integrations/llms/baichuan).
-
-```python
-from langchain_community.llms import BaichuanLLM
-```
-
-## Chat models
-
-See a [usage example](/docs/integrations/chat/baichuan).
-
-```python
-from langchain_community.chat_models import ChatBaichuan
-```
-
-## Embedding models
-
-See a [usage example](/docs/integrations/text_embedding/baichuan).
-
-```python
-from langchain_community.embeddings import BaichuanTextEmbeddings
-```

langchain_md_files/integrations/providers/baidu.mdx

@@ -1,72 +0,0 @@
-# Baidu
-
->[Baidu Cloud](https://cloud.baidu.com/) is a cloud service provided by `Baidu, Inc.`, 
-> headquartered in Beijing. It offers a cloud storage service, client software, 
-> file management, resource sharing, and Third Party Integration.
-
-
-## Installation and Setup
-
-Register and get the `Qianfan` `AK` and `SK` keys [here](https://cloud.baidu.com/product/wenxinworkshop).
-
-## LLMs
-
-### Baidu Qianfan
-
-See a [usage example](/docs/integrations/llms/baidu_qianfan_endpoint).
-
-```python
-from langchain_community.llms import QianfanLLMEndpoint
-```
-
-## Chat models
-
-### Qianfan Chat Endpoint
-
-See a [usage example](/docs/integrations/chat/baidu_qianfan_endpoint).
-
-```python
-from langchain_community.chat_models import QianfanChatEndpoint
-```
-
-## Embedding models
-
-### Baidu Qianfan
-
-See a [usage example](/docs/integrations/text_embedding/baidu_qianfan_endpoint).
-
-```python
-from langchain_community.embeddings import QianfanEmbeddingsEndpoint
-```
-
-## Document loaders
-
-### Baidu BOS Directory Loader
-
-```python
-from langchain_community.document_loaders.baiducloud_bos_directory import BaiduBOSDirectoryLoader
-```
-
-### Baidu BOS File Loader
-
-```python
-from langchain_community.document_loaders.baiducloud_bos_file import BaiduBOSFileLoader
-```
-
-## Vector stores
-
-### Baidu Cloud ElasticSearch VectorSearch
-
-See a [usage example](/docs/integrations/vectorstores/baiducloud_vector_search).
-
-```python
-from langchain_community.vectorstores import BESVectorStore
-```
-
-### Baidu VectorDB
-
-See a [usage example](/docs/integrations/vectorstores/baiduvectordb).
-
-```python
-from langchain_community.vectorstores import BaiduVectorDB
-```

langchain_md_files/integrations/providers/bananadev.mdx

@@ -1,68 +0,0 @@
-# Banana
-
->[Banana](https://www.banana.dev/) provided serverless GPU inference for AI models, 
-> a CI/CD build pipeline and a simple Python framework (`Potassium`) to server your models.
-
-This page covers how to use the [Banana](https://www.banana.dev) ecosystem within LangChain.
-
-## Installation and Setup
-
-- Install the python package `banana-dev`:
-
-```bash
-pip install banana-dev
-```
-
-- Get an Banana api key from the [Banana.dev dashboard](https://app.banana.dev) and set it as an environment variable (`BANANA_API_KEY`)
-- Get your model's key and url slug from the model's details page.
-
-## Define your Banana Template
-
-You'll need to set up a Github repo for your Banana app. You can get started in 5 minutes using [this guide](https://docs.banana.dev/banana-docs/).
-
-Alternatively, for a ready-to-go LLM example, you can check out Banana's [CodeLlama-7B-Instruct-GPTQ](https://github.com/bananaml/demo-codellama-7b-instruct-gptq) GitHub repository. Just fork it and deploy it within Banana.
-
-Other starter repos are available [here](https://github.com/orgs/bananaml/repositories?q=demo-&type=all&language=&sort=).
-
-## Build the Banana app
-
-To use Banana apps within Langchain, you must include the `outputs` key 
-in the returned json, and the value must be a string.
-
-```python
-# Return the results as a dictionary
-result = {'outputs': result}
-```
-
-An example inference function would be:
-
-```python
-@app.handler("/")
-def handler(context: dict, request: Request) -> Response:
-    """Handle a request to generate code from a prompt."""
-    model = context.get("model")
-    tokenizer = context.get("tokenizer")
-    max_new_tokens = request.json.get("max_new_tokens", 512)
-    temperature = request.json.get("temperature", 0.7)
-    prompt = request.json.get("prompt")
-    prompt_template=f'''[INST] Write code to solve the following coding problem that obeys the constraints and passes the example test cases. Please wrap your code answer using ```:
-    {prompt}
-    [/INST]
-    '''
-    input_ids = tokenizer(prompt_template, return_tensors='pt').input_ids.cuda()
-    output = model.generate(inputs=input_ids, temperature=temperature, max_new_tokens=max_new_tokens)
-    result = tokenizer.decode(output[0])
-    return Response(json={"outputs": result}, status=200)
-```
-
-This example is from the `app.py` file in [CodeLlama-7B-Instruct-GPTQ](https://github.com/bananaml/demo-codellama-7b-instruct-gptq).
-
-
-## LLM
-
-
-```python
-from langchain_community.llms import Banana
-```
-
-See a [usage example](/docs/integrations/llms/banana).

langchain_md_files/integrations/providers/beam.mdx

@@ -1,28 +0,0 @@
-# Beam
-
->[Beam](https://www.beam.cloud/) is a cloud computing platform that allows you to run your code 
-> on remote servers with GPUs.
-
-
-## Installation and Setup
-
-- [Create an account](https://www.beam.cloud/)
-- Install the Beam CLI with `curl https://raw.githubusercontent.com/slai-labs/get-beam/main/get-beam.sh -sSfL | sh`
-- Register API keys with `beam configure`
-- Set environment variables (`BEAM_CLIENT_ID`) and (`BEAM_CLIENT_SECRET`)
-- Install the Beam SDK:
-
-```bash
-pip install beam-sdk
-```
-
-
-## LLMs
-
-See a [usage example](/docs/integrations/llms/beam).
-
-See another example in the [Beam documentation](https://docs.beam.cloud/examples/langchain).
-
-```python
-from langchain_community.llms.beam import Beam
-```

langchain_md_files/integrations/providers/beautiful_soup.mdx

@@ -1,20 +0,0 @@
-# Beautiful Soup
-
->[Beautiful Soup](https://www.crummy.com/software/BeautifulSoup/) is a Python package for parsing 
-> HTML and XML documents (including having malformed markup, i.e. non-closed tags, so named after tag soup). 
-> It creates a parse tree for parsed pages that can be used to extract data from HTML,[3] which 
-> is useful for web scraping.
-
-## Installation and Setup
-
-```bash
-pip install beautifulsoup4
-```
-
-## Document Transformer
-
-See a [usage example](/docs/integrations/document_transformers/beautiful_soup).
-
-```python
-from langchain_community.document_loaders import BeautifulSoupTransformer
-```

langchain_md_files/integrations/providers/bibtex.mdx

@@ -1,20 +0,0 @@
-# BibTeX
-
->[BibTeX](https://www.ctan.org/pkg/bibtex) is a file format and reference management system commonly used in conjunction with `LaTeX` typesetting. It serves as a way to organize and store bibliographic information for academic and research documents.
-
-## Installation and Setup
-
-We have to install the `bibtexparser` and `pymupdf` packages.
-
-```bash
-pip install bibtexparser pymupdf
-```
-
-
-## Document loader
-
-See a [usage example](/docs/integrations/document_loaders/bibtex).
-
-```python
-from langchain_community.document_loaders import BibtexLoader
-```

langchain_md_files/integrations/providers/bilibili.mdx

@@ -1,17 +0,0 @@
-# BiliBili
-
->[Bilibili](https://www.bilibili.tv/) is one of the most beloved long-form video sites in China.
-
-## Installation and Setup
-
-```bash
-pip install bilibili-api-python
-```
-
-## Document Loader
-
-See a [usage example](/docs/integrations/document_loaders/bilibili).
-
-```python
-from langchain_community.document_loaders import BiliBiliLoader
-```

langchain_md_files/integrations/providers/bittensor.mdx

@@ -1,17 +0,0 @@
-# Bittensor
-
->[Neural Internet Bittensor](https://neuralinternet.ai/) network, an open source protocol 
-> that powers a decentralized, blockchain-based, machine learning network.
-
-## Installation and Setup
-
-Get your API_KEY from [Neural Internet](https://neuralinternet.ai/).
-
-
-## LLMs
-
-See a [usage example](/docs/integrations/llms/bittensor).
-
-```python
-from langchain_community.llms import NIBittensorLLM
-```

langchain_md_files/integrations/providers/blackboard.mdx

@@ -1,22 +0,0 @@
-# Blackboard
-
->[Blackboard Learn](https://en.wikipedia.org/wiki/Blackboard_Learn) (previously the `Blackboard Learning Management System`)
-> is a web-based virtual learning environment and learning management system developed by Blackboard Inc. 
-> The software features course management, customizable open architecture, and scalable design that allows 
-> integration with student information systems and authentication protocols. It may be installed on local servers, 
-> hosted by `Blackboard ASP Solutions`, or provided as Software as a Service hosted on Amazon Web Services. 
-> Its main purposes are stated to include the addition of online elements to courses traditionally delivered 
-> face-to-face and development of completely online courses with few or no face-to-face meetings.
-
-## Installation and Setup
-
-There isn't any special setup for it.
-
-## Document Loader
-
-See a [usage example](/docs/integrations/document_loaders/blackboard).
-
-```python
-from langchain_community.document_loaders import BlackboardLoader
-
-```

langchain_md_files/integrations/providers/bookendai.mdx

@@ -1,18 +0,0 @@
-# bookend.ai
-
-LangChain implements an integration with embeddings provided by [bookend.ai](https://bookend.ai/).
-
-
-## Installation and Setup
-
-
-You need to register and get the `API_KEY` 
-from the [bookend.ai](https://bookend.ai/) website.
-
-## Embedding model
-
-See a [usage example](/docs/integrations/text_embedding/bookend).
-
-```python
-from langchain_community.embeddings import BookendEmbeddings
-```

langchain_md_files/integrations/providers/box.mdx

@@ -1,179 +0,0 @@
-# Box
-
-[Box](https://box.com) is the Intelligent Content Cloud, a single platform that enables 
-organizations to fuel collaboration, manage the entire content lifecycle, secure critical content, 
-and transform business workflows with enterprise AI. Founded in 2005, Box simplifies work for 
-leading global organizations, including AstraZeneca, JLL, Morgan Stanley, and Nationwide.
-
-In this package, we make available a number of ways to include Box content in your AI workflows. 
-
-### Installation and setup
-
-```bash
-pip install -U langchain-box
-
-```
-
-# langchain-box
-
-This package contains the LangChain integration with Box. For more information about
-Box, check out our [developer documentation](https://developer.box.com).
-
-## Pre-requisites
-
-In order to integrate with Box, you need a few things:
-
-* A Box instance — if you are not a current Box customer, sign up for a 
-[free dev account](https://account.box.com/signup/n/developer#ty9l3).
-* A Box app — more on how to 
-[create an app](https://developer.box.com/guides/getting-started/first-application/)
-* Your app approved in your Box instance — This is done by your admin.
-The good news is if you are using a free developer account, you are the admin.
-[Authorize your app](https://developer.box.com/guides/authorization/custom-app-approval/#manual-approval)
-
-## Authentication
-
-The `box-langchain` package offers some flexibility to authentication. The
-most basic authentication method is by using a developer token. This can be
-found in the [Box developer console](https://account.box.com/developers/console) 
-on the configuration screen. This token is purposely short-lived (1 hour) and is 
-intended for development. With this token, you can add it to your environment as 
-`BOX_DEVELOPER_TOKEN`, you can pass it directly to the loader, or you can use the 
-`BoxAuth` authentication helper class.
-
-We will cover passing it directly to the loader in the section below. 
-
-### BoxAuth helper class
-
-`BoxAuth` supports the following authentication methods:
-
-* Token — either a developer token or any token generated through the Box SDK
-* JWT with a service account
-* JWT with a specified user
-* CCG with a service account
-* CCG with a specified user
-
-:::note
-If using JWT authentication, you will need to download the configuration from the Box
-developer console after generating your public/private key pair. Place this file in your 
-application directory structure somewhere. You will use the path to this file when using
-the `BoxAuth` helper class.
-:::
-
-For more information, learn about how to 
-[set up a Box application](https://developer.box.com/guides/getting-started/first-application/),
-and check out the 
-[Box authentication guide](https://developer.box.com/guides/authentication/select/)
-for more about our different authentication options.
-
-Examples:
-
-**Token**
-
-```python
-from langchain_box.document_loaders import BoxLoader
-from langchain_box.utilities import BoxAuth, BoxAuthType
-
-auth = BoxAuth(
-    auth_type=BoxAuthType.TOKEN,
-    box_developer_token=box_developer_token
-)
-
-loader = BoxLoader(
-    box_auth=auth,
-    ...
-)
-```
-
-**JWT with a service account**
-
-```python
-from langchain_box.document_loaders import BoxLoader
-from langchain_box.utilities import BoxAuth, BoxAuthType
-
-auth = BoxAuth(
-    auth_type=BoxAuthType.JWT,
-    box_jwt_path=box_jwt_path
-)
-
-loader = BoxLoader(
-    box_auth=auth,
-    ...
-```
-
-**JWT with a specified user**
-
-```python
-from langchain_box.document_loaders import BoxLoader
-from langchain_box.utilities import BoxAuth, BoxAuthType
-
-auth = BoxAuth(
-    auth_type=BoxAuthType.JWT,
-    box_jwt_path=box_jwt_path,
-    box_user_id=box_user_id
-)
-
-loader = BoxLoader(
-    box_auth=auth,
-    ...
-```
-
-**CCG with a service account**
-
-```python
-from langchain_box.document_loaders import BoxLoader
-from langchain_box.utilities import BoxAuth, BoxAuthType
-
-auth = BoxAuth(
-    auth_type=BoxAuthType.CCG,
-    box_client_id=box_client_id,
-    box_client_secret=box_client_secret,
-    box_enterprise_id=box_enterprise_id
-)
-
-loader = BoxLoader(
-    box_auth=auth,
-    ...
-```
-
-**CCG with a specified user**
-
-```python
-from langchain_box.document_loaders import BoxLoader
-from langchain_box.utilities import BoxAuth, BoxAuthType
-
-auth = BoxAuth(
-    auth_type=BoxAuthType.CCG,
-    box_client_id=box_client_id,
-    box_client_secret=box_client_secret,
-    box_user_id=box_user_id
-)
-
-loader = BoxLoader(
-    box_auth=auth,
-    ...
-```
-
-If you wish to use OAuth2 with the authorization_code flow, please use `BoxAuthType.TOKEN` with the token you have acquired.
-
-## Document Loaders
-
-### BoxLoader
-
-[See usage example](/docs/integrations/document_loaders/box)
-
-```python
-from langchain_box.document_loaders import BoxLoader
-
-```
-
-## Retrievers
-
-### BoxRetriever
-
-[See usage example](/docs/integrations/retrievers/box)
-
-```python
-from langchain_box.retrievers import BoxRetriever
-
-```

langchain_md_files/integrations/providers/brave_search.mdx

@@ -1,36 +0,0 @@
-# Brave Search
-
-
->[Brave Search](https://en.wikipedia.org/wiki/Brave_Search) is a search engine developed by Brave Software.
-> - `Brave Search` uses its own web index. As of May 2022, it covered over 10 billion pages and was used to serve 92% 
-> of search results without relying on any third-parties, with the remainder being retrieved 
-> server-side from the Bing API or (on an opt-in basis) client-side from Google. According 
-> to Brave, the index was kept "intentionally smaller than that of Google or Bing" in order to 
-> help avoid spam and other low-quality content, with the disadvantage that "Brave Search is 
-> not yet as good as Google in recovering long-tail queries."
->- `Brave Search Premium`: As of April 2023 Brave Search is an ad-free website, but it will 
-> eventually switch to a new model that will include ads and premium users will get an ad-free experience.
-> User data including IP addresses won't be collected from its users by default. A premium account 
-> will be required for opt-in data-collection.
-
-
-## Installation and Setup
-
-To get access to the Brave Search API, you need to [create an account and get an API key](https://api.search.brave.com/app/dashboard).
-
-
-## Document Loader
-
-See a [usage example](/docs/integrations/document_loaders/brave_search).
-
-```python
-from langchain_community.document_loaders import BraveSearchLoader
-```
-
-## Tool
-
-See a [usage example](/docs/integrations/tools/brave_search).
-
-```python
-from langchain.tools import BraveSearch
-```

langchain_md_files/integrations/providers/browserbase.mdx

@@ -1,34 +0,0 @@
-# Browserbase
-
-[Browserbase](https://browserbase.com) is a developer platform to reliably run, manage, and monitor headless browsers.
-
-Power your AI data retrievals with:
-- [Serverless Infrastructure](https://docs.browserbase.com/under-the-hood) providing reliable browsers to extract data from complex UIs
-- [Stealth Mode](https://docs.browserbase.com/features/stealth-mode) with included fingerprinting tactics and automatic captcha solving
-- [Session Debugger](https://docs.browserbase.com/features/sessions) to inspect your Browser Session with networks timeline and logs
-- [Live Debug](https://docs.browserbase.com/guides/session-debug-connection/browser-remote-control) to quickly debug your automation
-
-## Installation and Setup
-
-- Get an API key and Project ID from [browserbase.com](https://browserbase.com) and set it in environment variables (`BROWSERBASE_API_KEY`, `BROWSERBASE_PROJECT_ID`).
-- Install the [Browserbase SDK](http://github.com/browserbase/python-sdk):
-
-```python
-pip install browserbase
-```
-
-## Document loader
-
-See a [usage example](/docs/integrations/document_loaders/browserbase).
-
-```python
-from langchain_community.document_loaders import BrowserbaseLoader
-```
-
-## Multi-Modal
-
-See a [usage example](/docs/integrations/document_loaders/browserbase).
-
-```python
-from browserbase.helpers.gpt4 import GPT4VImage, GPT4VImageDetail
-```

langchain_md_files/integrations/providers/browserless.mdx

@@ -1,18 +0,0 @@
-# Browserless
-
->[Browserless](https://www.browserless.io/docs/start) is a service that allows you to 
-> run headless Chrome instances in the cloud. It’s a great way to run browser-based 
-> automation at scale without having to worry about managing your own infrastructure.
-
-## Installation and Setup
-
-We have to get the API key [here](https://www.browserless.io/pricing/).
-
-
-## Document loader
-
-See a [usage example](/docs/integrations/document_loaders/browserless).
-
-```python
-from langchain_community.document_loaders import BrowserlessLoader
-```

langchain_md_files/integrations/providers/byte_dance.mdx

@@ -1,22 +0,0 @@
-# ByteDance
-
->[ByteDance](https://bytedance.com/) is a Chinese internet technology company.
-
-## Installation and Setup
-
-Get the access token.
-You can find the access instructions [here](https://open.larksuite.com/document)
-
-
-## Document Loader
-
-### Lark Suite
-
->[Lark Suite](https://www.larksuite.com/) is an enterprise collaboration platform 
-> developed by `ByteDance`.
-
-See a [usage example](/docs/integrations/document_loaders/larksuite).
-
-```python
-from langchain_community.document_loaders.larksuite import LarkSuiteDocLoader
-```

langchain_md_files/integrations/providers/cassandra.mdx

@@ -1,85 +0,0 @@
-# Cassandra
-
-> [Apache Cassandra®](https://cassandra.apache.org/) is a NoSQL, row-oriented, highly scalable and highly available database.
-> Starting with version 5.0, the database ships with [vector search capabilities](https://cassandra.apache.org/doc/trunk/cassandra/vector-search/overview.html).
-
-The integrations outlined in this page can be used with `Cassandra` as well as other CQL-compatible databases, 
-i.e. those using the `Cassandra Query Language` protocol.
-
-
-## Installation and Setup
-
-Install the following Python package:
-
-```bash
-pip install "cassio>=0.1.6"
-```
-
-## Vector Store
-
-```python
-from langchain_community.vectorstores import Cassandra
-```
-
-Learn more in the [example notebook](/docs/integrations/vectorstores/cassandra).
-
-## Chat message history
-
-```python
-from langchain_community.chat_message_histories import CassandraChatMessageHistory
-```
-
-Learn more in the [example notebook](/docs/integrations/memory/cassandra_chat_message_history).
-
-
-## LLM Cache
-
-```python
-from langchain.globals import set_llm_cache
-from langchain_community.cache import CassandraCache
-set_llm_cache(CassandraCache())
-```
-
-Learn more in the [example notebook](/docs/integrations/llm_caching#cassandra-caches) (scroll to the Cassandra section).
-
-
-## Semantic LLM Cache
-
-```python
-from langchain.globals import set_llm_cache
-from langchain_community.cache import CassandraSemanticCache
-set_llm_cache(CassandraSemanticCache(
-    embedding=my_embedding,
-    table_name="my_store",
-))
-```
-
-Learn more in the [example notebook](/docs/integrations/llm_caching#cassandra-caches) (scroll to the appropriate section).
-
-## Document loader
-
-```python
-from langchain_community.document_loaders import CassandraLoader
-```
-
-Learn more in the [example notebook](/docs/integrations/document_loaders/cassandra).
-
-#### Attribution statement
-
-> Apache Cassandra, Cassandra and Apache are either registered trademarks or trademarks of 
-> the [Apache Software Foundation](http://www.apache.org/) in the United States and/or other countries.
-
-## Toolkit
-
-The `Cassandra Database toolkit` enables AI engineers to efficiently integrate agents
-with Cassandra data.
-
-```python
-from langchain_community.agent_toolkits.cassandra_database.toolkit import (
-    CassandraDatabaseToolkit,
-)
-```
-
-Learn more in the [example notebook](/docs/integrations/tools/cassandra_database).
-
-

langchain_md_files/integrations/providers/cerebriumai.mdx

@@ -1,26 +0,0 @@
-# CerebriumAI
-
->[Cerebrium](https://docs.cerebrium.ai/cerebrium/getting-started/introduction)  is a serverless GPU infrastructure provider.
-> It provides API access to several LLM models.
-
-See the examples in the [CerebriumAI documentation](https://docs.cerebrium.ai/examples/langchain).
-
-## Installation and Setup
-
-- Install a python package:
-```bash
-pip install cerebrium
-```
-
-- [Get an CerebriumAI api key](https://docs.cerebrium.ai/cerebrium/getting-started/installation) and set 
-  it as an environment variable (`CEREBRIUMAI_API_KEY`)
-
-
-## LLMs
-
-See a [usage example](/docs/integrations/llms/cerebriumai).
-
-
-```python
-from langchain_community.llms import CerebriumAI
-```

langchain_md_files/integrations/providers/chaindesk.mdx

@@ -1,17 +0,0 @@
-# Chaindesk
-
->[Chaindesk](https://chaindesk.ai) is an [open-source](https://github.com/gmpetrov/databerry) document retrieval platform that helps to connect your personal data with Large Language Models.
-
-
-## Installation and Setup
-
-We need to sign up for Chaindesk, create a datastore, add some data and get your datastore api endpoint url. 
-We need the [API Key](https://docs.chaindesk.ai/api-reference/authentication).
-
-## Retriever
-
-See a [usage example](/docs/integrations/retrievers/chaindesk).
-
-```python
-from langchain.retrievers import ChaindeskRetriever
-```

langchain_md_files/integrations/providers/chroma.mdx

@@ -1,29 +0,0 @@
-# Chroma
-
->[Chroma](https://docs.trychroma.com/getting-started) is a database for building AI applications with embeddings.
-
-## Installation and Setup
-
-```bash
-pip install langchain-chroma
-```
-
-
-## VectorStore
-
-There exists a wrapper around Chroma vector databases, allowing you to use it as a vectorstore,
-whether for semantic search or example selection.
-
-```python
-from langchain_chroma import Chroma
-```
-
-For a more detailed walkthrough of the Chroma wrapper, see [this notebook](/docs/integrations/vectorstores/chroma)
-
-## Retriever
-
-See a [usage example](/docs/integrations/retrievers/self_query/chroma_self_query).
-
-```python
-from langchain.retrievers import SelfQueryRetriever
-```

langchain_md_files/integrations/providers/clarifai.mdx

@@ -1,53 +0,0 @@
-# Clarifai
-
->[Clarifai](https://clarifai.com) is one of first deep learning platforms having been founded in 2013. Clarifai provides an AI platform with the full AI lifecycle for data exploration, data labeling, model training, evaluation and inference around images, video, text and audio data. In the LangChain ecosystem, as far as we're aware, Clarifai is the only provider that supports LLMs, embeddings and a vector store in one production scale platform, making it an excellent choice to operationalize your LangChain implementations.
->
-> `Clarifai` provides 1,000s of AI models for many different use cases. You can [explore them here](https://clarifai.com/explore) to find the one most suited for your use case. These models include those created by other providers such as OpenAI, Anthropic, Cohere, AI21, etc. as well as state of the art from open source such as Falcon, InstructorXL, etc. so that you build the best in AI into your products. You'll find these organized by the creator's user_id and into projects we call applications denoted by their app_id. Those IDs will be needed in additional to the model_id and optionally the version_id, so make note of all these IDs once you found the best model for your use case!
->
->Also note that given there are many models for images, video, text and audio understanding, you can build some interested AI agents that utilize the variety of AI models as experts to understand those data types.
-
-
-## Installation and Setup
-- Install the Python SDK:
-```bash
-pip install clarifai
-```
-[Sign-up](https://clarifai.com/signup) for a Clarifai account, then get a personal access token to access the Clarifai API from your [security settings](https://clarifai.com/settings/security) and set it as an environment variable (`CLARIFAI_PAT`).
-
-
-## LLMs
-
-To find the selection of LLMs in the Clarifai platform you can select the text to text model type [here](https://clarifai.com/explore/models?filterData=%5B%7B%22field%22%3A%22model_type_id%22%2C%22value%22%3A%5B%22text-to-text%22%5D%7D%5D&page=1&perPage=24).
-
-```python
-from langchain_community.llms import Clarifai
-llm = Clarifai(pat=CLARIFAI_PAT, user_id=USER_ID, app_id=APP_ID, model_id=MODEL_ID)
-```
-
-For more details, the docs on the Clarifai LLM wrapper provide a [detailed walkthrough](/docs/integrations/llms/clarifai).
-
-
-## Embedding Models
-
-To find the selection of embeddings models in the Clarifai platform you can select the text to embedding model type [here](https://clarifai.com/explore/models?page=1&perPage=24&filterData=%5B%7B%22field%22%3A%22model_type_id%22%2C%22value%22%3A%5B%22text-embedder%22%5D%7D%5D).
-
-There is a Clarifai Embedding model in LangChain, which you can access with:
-```python
-from langchain_community.embeddings import ClarifaiEmbeddings
-embeddings = ClarifaiEmbeddings(pat=CLARIFAI_PAT, user_id=USER_ID, app_id=APP_ID, model_id=MODEL_ID)
-```
-
-See a [usage example](/docs/integrations/document_loaders/couchbase).
-
-
-## Vectorstore
-
-Clarifai's vector DB was launched in 2016 and has been optimized to support live search queries. With workflows in the Clarifai platform, you data is automatically indexed by am embedding model and optionally other models as well to index that information in the DB for search. You can query the DB not only via the vectors but also filter by metadata matches, other AI predicted concepts, and even do geo-coordinate search. Simply create an application, select the appropriate base workflow for your type of data, and upload it (through the API as [documented here](https://docs.clarifai.com/api-guide/data/create-get-update-delete) or the UIs at clarifai.com).
-
-You can also add data directly from LangChain as well, and the auto-indexing will take place for you. You'll notice this is a little different than other vectorstores where you need to provide an embedding model in their constructor and have LangChain coordinate getting the embeddings from text and writing those to the index. Not only is it more convenient, but it's much more scalable to use Clarifai's distributed cloud to do all the index in the background.
-
-```python
-from langchain_community.vectorstores import Clarifai
-clarifai_vector_db = Clarifai.from_texts(user_id=USER_ID, app_id=APP_ID, texts=texts, pat=CLARIFAI_PAT, number_of_docs=NUMBER_OF_DOCS, metadatas = metadatas)
-```
-For more details, the docs on the Clarifai vector store provide a [detailed walkthrough](/docs/integrations/vectorstores/clarifai).

langchain_md_files/integrations/providers/clickhouse.mdx

@@ -1,25 +0,0 @@
-# ClickHouse
-
-> [ClickHouse](https://clickhouse.com/) is the fast and resource efficient open-source database for real-time 
-> apps and analytics with full SQL support and a wide range of functions to assist users in writing analytical queries. 
-> It has data structures and distance search functions (like `L2Distance`) as well as 
-> [approximate nearest neighbor search indexes](https://clickhouse.com/docs/en/engines/table-engines/mergetree-family/annindexes) 
-> That enables ClickHouse to be used as a high performance and scalable vector database to store and search vectors with SQL.
-
-
-## Installation and Setup
-
-We need to install `clickhouse-connect` python package.
-
-```bash
-pip install clickhouse-connect
-```
-
-## Vector Store
-
-See a [usage example](/docs/integrations/vectorstores/clickhouse).
-
-```python
-from langchain_community.vectorstores import Clickhouse, ClickhouseSettings
-```
-

langchain_md_files/integrations/providers/clickup.mdx

@@ -1,20 +0,0 @@
-# ClickUp
-
->[ClickUp](https://clickup.com/) is an all-in-one productivity platform that provides small and large teams across industries with flexible and customizable work management solutions, tools, and functions.
->
->It is a cloud-based project management solution for businesses of all sizes featuring communication and collaboration tools to help achieve organizational goals.
-
-## Installation and Setup
-
-1. Create a [ClickUp App](https://help.clickup.com/hc/en-us/articles/6303422883095-Create-your-own-app-with-the-ClickUp-API)
-2. Follow [these steps](https://clickup.com/api/developer-portal/authentication/) to get your client_id and client_secret.
-
-## Toolkits
-
-```python
-from langchain_community.agent_toolkits.clickup.toolkit import ClickupToolkit
-from langchain_community.utilities.clickup import ClickupAPIWrapper
-```
-
-See a [usage example](/docs/integrations/tools/clickup).
-

langchain_md_files/integrations/providers/cloudflare.mdx

@@ -1,25 +0,0 @@
-# Cloudflare
-
->[Cloudflare, Inc. (Wikipedia)](https://en.wikipedia.org/wiki/Cloudflare) is an American company that provides 
-> content delivery network services, cloud cybersecurity, DDoS mitigation, and ICANN-accredited 
-> domain registration services.
-
->[Cloudflare Workers AI](https://developers.cloudflare.com/workers-ai/) allows you to run machine 
-> learning models, on the `Cloudflare` network, from your code via REST API.
-
-
-## LLMs
-
-See [installation instructions and usage example](/docs/integrations/llms/cloudflare_workersai).
-
-```python
-from langchain_community.llms.cloudflare_workersai import CloudflareWorkersAI
-```
-
-## Embedding models
-
-See [installation instructions and usage example](/docs/integrations/text_embedding/cloudflare_workersai).
-
-```python
-from langchain_community.embeddings.cloudflare_workersai import CloudflareWorkersAIEmbeddings
-```

langchain_md_files/integrations/providers/clova.mdx

@@ -1,14 +0,0 @@
-# Clova
-
->[CLOVA Studio](https://api.ncloud-docs.com/docs/ai-naver-clovastudio-summary) is a service 
-> of [Naver Cloud Platform](https://www.ncloud.com/) that uses `HyperCLOVA` language models, 
-> a hyperscale AI technology, to output phrases generated through AI technology based on user input.
-
-
-## Embedding models
-
-See [installation instructions and usage example](/docs/integrations/text_embedding/clova).
-
-```python
-from langchain_community.embeddings import ClovaEmbeddings
-```

langchain_md_files/integrations/providers/cnosdb.mdx

@@ -1,110 +0,0 @@
-# CnosDB
-> [CnosDB](https://github.com/cnosdb/cnosdb) is an open-source distributed time series database with high performance, high compression rate and high ease of use.
-
-## Installation and Setup
-
-```python
-pip install cnos-connector
-```
-
-## Connecting to CnosDB
-You can connect to CnosDB using the `SQLDatabase.from_cnosdb()` method.
-### Syntax
-```python
-def SQLDatabase.from_cnosdb(url: str = "127.0.0.1:8902",
-                              user: str = "root",
-                              password: str = "",
-                              tenant: str = "cnosdb",
-                              database: str = "public")
-```
-Args:
-1. url (str): The HTTP connection host name and port number of the CnosDB
-                service, excluding "http://" or "https://", with a default value
-                of "127.0.0.1:8902".
-2. user (str): The username used to connect to the CnosDB service, with a
-                default value of "root".
-3. password (str): The password of the user connecting to the CnosDB service,
-                with a default value of "".
-4. tenant (str): The name of the tenant used to connect to the CnosDB service,
-                with a default value of "cnosdb".
-5. database (str): The name of the database in the CnosDB tenant.
-## Examples
-```python
-# Connecting to CnosDB with SQLDatabase Wrapper
-from langchain_community.utilities import SQLDatabase
-
-db = SQLDatabase.from_cnosdb()
-```
-```python
-# Creating a OpenAI Chat LLM Wrapper
-from langchain_openai import ChatOpenAI
-
-llm = ChatOpenAI(temperature=0, model_name="gpt-3.5-turbo")
-```
-
-### SQL Database Chain
-This example demonstrates the use of the SQL Chain for answering a question over a CnosDB.
-```python
-from langchain_community.utilities import SQLDatabaseChain
-
-db_chain = SQLDatabaseChain.from_llm(llm, db, verbose=True)
-
-db_chain.run(
-    "What is the average temperature of air at station XiaoMaiDao between October 19, 2022 and Occtober 20, 2022?"
-)
-```
-```shell
-> Entering new  chain...
-What is the average temperature of air at station XiaoMaiDao between October 19, 2022 and Occtober 20, 2022?
-SQLQuery:SELECT AVG(temperature) FROM air WHERE station = 'XiaoMaiDao' AND time >= '2022-10-19' AND time < '2022-10-20'
-SQLResult: [(68.0,)]
-Answer:The average temperature of air at station XiaoMaiDao between October 19, 2022 and October 20, 2022 is 68.0.
-> Finished chain.
-```
-### SQL Database Agent
-This example demonstrates the use of the SQL Database Agent for answering questions over a CnosDB.
-```python
-from langchain.agents import create_sql_agent
-from langchain_community.agent_toolkits import SQLDatabaseToolkit
-
-toolkit = SQLDatabaseToolkit(db=db, llm=llm)
-agent = create_sql_agent(llm=llm, toolkit=toolkit, verbose=True)
-```
-```python
-agent.run(
-    "What is the average temperature of air at station XiaoMaiDao between October 19, 2022 and Occtober 20, 2022?"
-)
-```
-```shell
-> Entering new  chain...
-Action: sql_db_list_tables
-Action Input: ""
-Observation: air
-Thought:The "air" table seems relevant to the question. I should query the schema of the "air" table to see what columns are available.
-Action: sql_db_schema
-Action Input: "air"
-Observation:
-CREATE TABLE air (
-	pressure FLOAT,
-	station STRING,
-	temperature FLOAT,
-	time TIMESTAMP,
-	visibility FLOAT
-)
-
-/*
-3 rows from air table:
-pressure	station	temperature	time	visibility
-75.0	XiaoMaiDao	67.0	2022-10-19T03:40:00	54.0
-77.0	XiaoMaiDao	69.0	2022-10-19T04:40:00	56.0
-76.0	XiaoMaiDao	68.0	2022-10-19T05:40:00	55.0
-*/
-Thought:The "temperature" column in the "air" table is relevant to the question. I can query the average temperature between the specified dates.
-Action: sql_db_query
-Action Input: "SELECT AVG(temperature) FROM air WHERE station = 'XiaoMaiDao' AND time >= '2022-10-19' AND time <= '2022-10-20'"
-Observation: [(68.0,)]
-Thought:The average temperature of air at station XiaoMaiDao between October 19, 2022 and October 20, 2022 is 68.0.
-Final Answer: 68.0
-
-> Finished chain.
-```

langchain_md_files/integrations/providers/cogniswitch.mdx

@@ -1,53 +0,0 @@
-# CogniSwitch
-
->[CogniSwitch](https://www.cogniswitch.ai/aboutus) is an API based data platform that 
-> enhances enterprise data by extracting entities, concepts and their relationships 
-> thereby converting this data into a multidimensional format and storing it in 
-> a database that can accommodate these enhancements. In our case the data is stored 
-> in a knowledge graph. This enhanced data is now ready for consumption by LLMs and 
-> other GenAI applications ensuring the data is consumable and context can be maintained. 
-> Thereby eliminating hallucinations and delivering accuracy.
-
-## Toolkit
-
-See [installation instructions and usage example](/docs/integrations/tools/cogniswitch).
-
-```python
-from langchain_community.agent_toolkits import CogniswitchToolkit
-```
-
-## Tools
-
-### CogniswitchKnowledgeRequest
-
->Tool that uses the CogniSwitch service to answer questions.
-
-```python
-from langchain_community.tools.cogniswitch.tool import CogniswitchKnowledgeRequest
-```
-
-### CogniswitchKnowledgeSourceFile
-
->Tool that uses the CogniSwitch services to store data from file.
-
-```python
-from langchain_community.tools.cogniswitch.tool import CogniswitchKnowledgeSourceFile
-```
-
-### CogniswitchKnowledgeSourceURL
-
->Tool that uses the CogniSwitch services to store data from a URL.
-
-```python
-from langchain_community.tools.cogniswitch.tool import CogniswitchKnowledgeSourceURL
-```
-
-### CogniswitchKnowledgeStatus
-
->Tool that uses the CogniSwitch services to get the status of the document or url uploaded.
-
-```python
-from langchain_community.tools.cogniswitch.tool import CogniswitchKnowledgeStatus
-```
-
-

langchain_md_files/integrations/providers/cohere.mdx

@@ -1,157 +0,0 @@
-# Cohere
-
->[Cohere](https://cohere.ai/about) is a Canadian startup that provides natural language processing models
-> that help companies improve human-machine interactions.
-
-## Installation and Setup
-- Install the Python SDK :
-```bash
-pip install langchain-cohere
-```
-
-Get a [Cohere api key](https://dashboard.cohere.ai/) and set it as an environment variable (`COHERE_API_KEY`)
-
-## Cohere langchain integrations
-
-|API|description|Endpoint docs|Import|Example usage|
-|---|---|---|---|---|
-|Chat|Build chat bots|[chat](https://docs.cohere.com/reference/chat)|`from langchain_cohere import ChatCohere`|[cohere.ipynb](/docs/integrations/chat/cohere)|
-|LLM|Generate text|[generate](https://docs.cohere.com/reference/generate)|`from langchain_cohere.llms import Cohere`|[cohere.ipynb](/docs/integrations/llms/cohere)|
-|RAG Retriever|Connect to external data sources|[chat + rag](https://docs.cohere.com/reference/chat)|`from langchain.retrievers import CohereRagRetriever`|[cohere.ipynb](/docs/integrations/retrievers/cohere)|
-|Text Embedding|Embed strings to vectors|[embed](https://docs.cohere.com/reference/embed)|`from langchain_cohere import CohereEmbeddings`|[cohere.ipynb](/docs/integrations/text_embedding/cohere)|
-|Rerank Retriever|Rank strings based on relevance|[rerank](https://docs.cohere.com/reference/rerank)|`from langchain.retrievers.document_compressors import CohereRerank`|[cohere.ipynb](/docs/integrations/retrievers/cohere-reranker)|
-
-## Quick copy examples
-
-### Chat
-
-```python
-from langchain_cohere import ChatCohere
-from langchain_core.messages import HumanMessage
-chat = ChatCohere()
-messages = [HumanMessage(content="knock knock")]
-print(chat.invoke(messages))
-```
-
-Usage of the Cohere [chat model](/docs/integrations/chat/cohere)
-
-### LLM
-
-
-```python
-from langchain_cohere.llms import Cohere
-
-llm = Cohere()
-print(llm.invoke("Come up with a pet name"))
-```
-
-Usage of the Cohere (legacy) [LLM model](/docs/integrations/llms/cohere) 
-
-### Tool calling
-```python
-from langchain_cohere import ChatCohere
-from langchain_core.messages import (
-    HumanMessage,
-    ToolMessage,
-)
-from langchain_core.tools import tool
-
-@tool
-def magic_function(number: int) -> int:
-    """Applies a magic operation to an integer
-
-    Args:
-        number: Number to have magic operation performed on
-    """
-    return number + 10
-
-def invoke_tools(tool_calls, messages):
-    for tool_call in tool_calls:
-        selected_tool = {"magic_function":magic_function}[
-            tool_call["name"].lower()
-        ]
-        tool_output = selected_tool.invoke(tool_call["args"])
-        messages.append(ToolMessage(tool_output, tool_call_id=tool_call["id"]))
-    return messages
-
-tools = [magic_function]
-
-llm = ChatCohere()
-llm_with_tools = llm.bind_tools(tools=tools)
-messages = [
-    HumanMessage(
-        content="What is the value of magic_function(2)?"
-    )
-]
-
-res = llm_with_tools.invoke(messages)
-while res.tool_calls:
-    messages.append(res)
-    messages = invoke_tools(res.tool_calls, messages)
-    res = llm_with_tools.invoke(messages)
-
-print(res.content)
-```
-Tool calling with Cohere LLM can be done by binding the necessary tools to the llm as seen above. 
-An alternative, is to support multi hop tool calling with the ReAct agent as seen below.
-
-### ReAct Agent
-
-The agent is based on the paper
-[ReAct: Synergizing Reasoning and Acting in Language Models](https://arxiv.org/abs/2210.03629).
-
-```python
-from langchain_community.tools.tavily_search import TavilySearchResults
-from langchain_cohere import ChatCohere, create_cohere_react_agent
-from langchain_core.prompts import ChatPromptTemplate
-from langchain.agents import AgentExecutor
-
-llm = ChatCohere()
-
-internet_search = TavilySearchResults(max_results=4)
-internet_search.name = "internet_search"
-internet_search.description = "Route a user query to the internet"
-
-prompt = ChatPromptTemplate.from_template("{input}")
-
-agent = create_cohere_react_agent(
-    llm,
-    [internet_search],
-    prompt
-)
-
-agent_executor = AgentExecutor(agent=agent, tools=[internet_search], verbose=True)
-
-agent_executor.invoke({
-    "input": "In what year was the company that was founded as Sound of Music added to the S&P 500?",
-})
-```
-The ReAct agent can be used to call multiple tools in sequence.
-
-### RAG Retriever
-
-```python
-from langchain_cohere import ChatCohere
-from langchain.retrievers import CohereRagRetriever
-from langchain_core.documents import Document
-
-rag = CohereRagRetriever(llm=ChatCohere())
-print(rag.invoke("What is cohere ai?"))
-```
-
-Usage of the Cohere [RAG Retriever](/docs/integrations/retrievers/cohere)
-
-### Text Embedding
-
-```python
-from langchain_cohere import CohereEmbeddings
-
-embeddings = CohereEmbeddings(model="embed-english-light-v3.0")
-print(embeddings.embed_documents(["This is a test document."]))
-```
-
-Usage of the Cohere [Text Embeddings model](/docs/integrations/text_embedding/cohere)
-
-### Reranker
-
-Usage of the Cohere [Reranker](/docs/integrations/retrievers/cohere-reranker)

langchain_md_files/integrations/providers/college_confidential.mdx

@@ -1,16 +0,0 @@
-# College Confidential
-
->[College Confidential](https://www.collegeconfidential.com/) gives information on 3,800+ colleges and universities.
-
-## Installation and Setup
-
-There isn't any special setup for it.
-
-
-## Document Loader
-
-See a [usage example](/docs/integrations/document_loaders/college_confidential).
-
-```python
-from langchain_community.document_loaders import CollegeConfidentialLoader
-```

langchain_md_files/integrations/providers/confident.mdx

@@ -1,26 +0,0 @@
-# Confident AI
-
->[Confident AI](https://confident-ai.com) is a creator of the `DeepEval`.
->
->[DeepEval](https://github.com/confident-ai/deepeval) is a package for unit testing LLMs.
-> Using `DeepEval`, everyone can build robust language models through faster iterations
-> using both unit testing and integration testing. `DeepEval provides support for each step in the iteration
-> from synthetic data creation to testing.
-
-## Installation and Setup
-
-You need to get the [DeepEval API credentials](https://app.confident-ai.com).
-
-You need to install the `DeepEval` Python package:
-
-```bash
-pip install deepeval
-```
-
-## Callbacks
-
-See an [example](/docs/integrations/callbacks/confident).
-
-```python
-from langchain.callbacks.confident_callback import DeepEvalCallbackHandler
-```

langchain_md_files/integrations/providers/confluence.mdx

@@ -1,22 +0,0 @@
-# Confluence
-
->[Confluence](https://www.atlassian.com/software/confluence) is a wiki collaboration platform that saves and organizes all of the project-related material. `Confluence` is a knowledge base that primarily handles content management activities. 
-
-
-## Installation and Setup
-
-```bash
-pip install atlassian-python-api
-```
-
-We need to set up `username/api_key` or `Oauth2 login`. 
-See [instructions](https://support.atlassian.com/atlassian-account/docs/manage-api-tokens-for-your-atlassian-account/).
-
-
-## Document Loader
-
-See a [usage example](/docs/integrations/document_loaders/confluence).
-
-```python
-from langchain_community.document_loaders import ConfluenceLoader
-```

langchain_md_files/integrations/providers/connery.mdx

@@ -1,28 +0,0 @@
-# Connery
-
->[Connery SDK](https://github.com/connery-io/connery-sdk) is an NPM package that 
-> includes both an SDK and a CLI, designed for the development of plugins and actions.
->
->The CLI automates many things in the development process. The SDK 
-> offers a JavaScript API for defining plugins and actions and packaging them 
-> into a plugin server with a standardized REST API generated from the metadata. 
-> The plugin server handles authorization, input validation, and logging. 
-> So you can focus on the logic of your actions.
-> 
-> See the use cases and examples in the [Connery SDK documentation](https://sdk.connery.io/docs/use-cases/)
-
-## Toolkit
-
-See [usage example](/docs/integrations/tools/connery).
-
-```python
-from langchain_community.agent_toolkits.connery import ConneryToolkit
-```
-
-## Tools
-
-### ConneryAction
-
-```python
-from langchain_community.tools.connery import ConneryService
-```

langchain_md_files/integrations/providers/context.mdx

@@ -1,20 +0,0 @@
-# Context
-
->[Context](https://context.ai/) provides user analytics for LLM-powered products and features.
-
-## Installation and Setup
-
-We need to install the  `context-python` Python package:
-
-```bash
-pip install context-python
-```
-
-
-## Callbacks
-
-See a [usage example](/docs/integrations/callbacks/context).
-
-```python
-from langchain.callbacks import ContextCallbackHandler
-```

langchain_md_files/integrations/providers/couchbase.mdx

@@ -1,111 +0,0 @@
-# Couchbase
-
->[Couchbase](http://couchbase.com/) is an award-winning distributed NoSQL cloud database 
-> that delivers unmatched versatility, performance, scalability, and financial value 
-> for all of your cloud, mobile, AI, and edge computing applications.
-
-## Installation and Setup
-
-We have to install the `langchain-couchbase` package.
-
-```bash
-pip install langchain-couchbase
-```
-
-## Vector Store
-
-See a [usage example](/docs/integrations/vectorstores/couchbase).
-
-```python
-from langchain_couchbase import CouchbaseVectorStore
-```
-
-## Document loader
-
-See a [usage example](/docs/integrations/document_loaders/couchbase).
-
-```python
-from langchain_community.document_loaders.couchbase import CouchbaseLoader
-```
-
-## LLM Caches
-
-### CouchbaseCache
-Use Couchbase as a cache for prompts and responses.
-
-See a [usage example](/docs/integrations/llm_caching/#couchbase-cache).
-
-To import this cache:
-```python
-from langchain_couchbase.cache import CouchbaseCache
-```
-
-To use this cache with your LLMs:
-```python
-from langchain_core.globals import set_llm_cache
-
-cluster = couchbase_cluster_connection_object
-
-set_llm_cache(
-    CouchbaseCache(
-        cluster=cluster,
-        bucket_name=BUCKET_NAME,
-        scope_name=SCOPE_NAME,
-        collection_name=COLLECTION_NAME,
-    )
-)
-```
-
-
-### CouchbaseSemanticCache
-Semantic caching allows users to retrieve cached prompts based on the semantic similarity between the user input and previously cached inputs. Under the hood it uses Couchbase as both a cache and a vectorstore.
-The CouchbaseSemanticCache needs a Search Index defined to work. Please look at the [usage example](/docs/integrations/vectorstores/couchbase) on how to set up the index.
-
-See a [usage example](/docs/integrations/llm_caching/#couchbase-semantic-cache).
-
-To import this cache:
-```python
-from langchain_couchbase.cache import CouchbaseSemanticCache
-```
-
-To use this cache with your LLMs:
-```python
-from langchain_core.globals import set_llm_cache
-
-# use any embedding provider...
-from langchain_openai.Embeddings import OpenAIEmbeddings
-
-embeddings = OpenAIEmbeddings()
-cluster = couchbase_cluster_connection_object
-
-set_llm_cache(
-    CouchbaseSemanticCache(
-        cluster=cluster,
-        embedding = embeddings,
-        bucket_name=BUCKET_NAME,
-        scope_name=SCOPE_NAME,
-        collection_name=COLLECTION_NAME,
-        index_name=INDEX_NAME,
-    )
-)
-```
-
-## Chat Message History
-Use Couchbase as the storage for your chat messages.
-
-See a [usage example](/docs/integrations/memory/couchbase_chat_message_history).
-
-To use the chat message history in your applications:
-```python
-from langchain_couchbase.chat_message_histories import CouchbaseChatMessageHistory
-
-message_history = CouchbaseChatMessageHistory(
-    cluster=cluster,
-    bucket_name=BUCKET_NAME,
-    scope_name=SCOPE_NAME,
-    collection_name=COLLECTION_NAME,
-    session_id="test-session",
-)
-
-message_history.add_user_message("hi!")
-```

langchain_md_files/integrations/providers/coze.mdx

@@ -1,19 +0,0 @@
-# Coze
-
-[Coze](https://www.coze.com/) is an AI chatbot development platform that enables
-the creation and deployment of chatbots for handling diverse conversations across
-various applications.
-
-
-## Installation and Setup
-
-First, you need to get the `API_KEY` from the [Coze](https://www.coze.com/) website.
-
-
-## Chat models
-
-See a [usage example](/docs/integrations/chat/coze/).
-
-```python
-from langchain_community.chat_models import ChatCoze
-```

langchain_md_files/integrations/providers/ctransformers.mdx

@@ -1,57 +0,0 @@
-# C Transformers
-
-This page covers how to use the [C Transformers](https://github.com/marella/ctransformers) library within LangChain.
-It is broken into two parts: installation and setup, and then references to specific C Transformers wrappers.
-
-## Installation and Setup
-
-- Install the Python package with `pip install ctransformers`
-- Download a supported [GGML model](https://huggingface.co/TheBloke) (see [Supported Models](https://github.com/marella/ctransformers#supported-models))
-
-## Wrappers
-
-### LLM
-
-There exists a CTransformers LLM wrapper, which you can access with:
-
-```python
-from langchain_community.llms import CTransformers
-```
-
-It provides a unified interface for all models:
-
-```python
-llm = CTransformers(model='/path/to/ggml-gpt-2.bin', model_type='gpt2')
-
-print(llm.invoke('AI is going to'))
-```
-
-If you are getting `illegal instruction` error, try using `lib='avx'` or `lib='basic'`:
-
-```py
-llm = CTransformers(model='/path/to/ggml-gpt-2.bin', model_type='gpt2', lib='avx')
-```
-
-It can be used with models hosted on the Hugging Face Hub:
-
-```py
-llm = CTransformers(model='marella/gpt-2-ggml')
-```
-
-If a model repo has multiple model files (`.bin` files), specify a model file using:
-
-```py
-llm = CTransformers(model='marella/gpt-2-ggml', model_file='ggml-model.bin')
-```
-
-Additional parameters can be passed using the `config` parameter:
-
-```py
-config = {'max_new_tokens': 256, 'repetition_penalty': 1.1}
-
-llm = CTransformers(model='marella/gpt-2-ggml', config=config)
-```
-
-See [Documentation](https://github.com/marella/ctransformers#config) for a list of available parameters.
-
-For a more detailed walkthrough of this, see [this notebook](/docs/integrations/llms/ctransformers).

langchain_md_files/integrations/providers/ctranslate2.mdx

@@ -1,30 +0,0 @@
-# CTranslate2
-
->[CTranslate2](https://opennmt.net/CTranslate2/quickstart.html) is a C++ and Python library 
-> for efficient inference with Transformer models.
->
->The project implements a custom runtime that applies many performance optimization
-> techniques such as weights quantization, layers fusion, batch reordering, etc., 
-> to accelerate and reduce the memory usage of Transformer models on CPU and GPU.
->
->A full list of features and supported models is included in the 
-> [project’s repository](https://opennmt.net/CTranslate2/guides/transformers.html). 
-> To start, please check out the official [quickstart guide](https://opennmt.net/CTranslate2/quickstart.html).
-
-
-## Installation and Setup
-
-Install the Python package:
-
-```bash
-pip install ctranslate2
-```
-
-
-## LLMs
-
-See a [usage example](/docs/integrations/llms/ctranslate2).
-
-```python
-from langchain_community.llms import CTranslate2
-```

langchain_md_files/integrations/providers/cube.mdx

@@ -1,21 +0,0 @@
-# Cube
-
->[Cube](https://cube.dev/) is the Semantic Layer for building data apps. It helps 
-> data engineers and application developers access data from modern data stores, 
-> organize it into consistent definitions, and deliver it to every application.
-
-## Installation and Setup
-
-We have to get the API key and the URL of the Cube instance. See 
-[these instructions](https://cube.dev/docs/product/apis-integrations/rest-api#configuration-base-path).
-
-
-## Document loader
-
-### Cube Semantic Layer
-
-See a [usage example](/docs/integrations/document_loaders/cube_semantic).
-
-```python
-from langchain_community.document_loaders import CubeSemanticLoader
-```

langchain_md_files/integrations/providers/dashvector.mdx

@@ -1,39 +0,0 @@
-# DashVector
-
-> [DashVector](https://help.aliyun.com/document_detail/2510225.html) is a fully-managed vectorDB service that supports high-dimension dense and sparse vectors, real-time insertion and filtered search. It is built to scale automatically and can adapt to different application requirements.  
-
-This document demonstrates to leverage DashVector within the LangChain ecosystem. In particular, it shows how to install DashVector, and how to use it as a VectorStore plugin in LangChain.
-It is broken into two parts: installation and setup, and then references to specific DashVector wrappers.
-
-## Installation and Setup
-
-
-Install the Python SDK:
-
-```bash
-pip install dashvector
-```
-
-You must have an API key. Here are the [installation instructions](https://help.aliyun.com/document_detail/2510223.html).
-
-
-## Embedding models
-
-```python
-from langchain_community.embeddings import DashScopeEmbeddings
-```
-
-See the [use example](/docs/integrations/vectorstores/dashvector).
-
-
-## Vector Store
-
-A DashVector Collection is wrapped as a familiar VectorStore for native usage within LangChain, 
-which allows it to be readily used for various scenarios, such as semantic search or example selection.
-
-You may import the vectorstore by:
-```python
-from langchain_community.vectorstores import DashVector
-```
-
-For a detailed walkthrough of the DashVector wrapper, please refer to [this notebook](/docs/integrations/vectorstores/dashvector)

langchain_md_files/integrations/providers/datadog.mdx

@@ -1,88 +0,0 @@
-# Datadog Tracing
-
->[ddtrace](https://github.com/DataDog/dd-trace-py) is a Datadog application performance monitoring (APM) library which provides an integration to monitor your LangChain application.
-
-Key features of the ddtrace integration for LangChain:
-- Traces: Capture LangChain requests, parameters, prompt-completions, and help visualize LangChain operations.
-- Metrics: Capture LangChain request latency, errors, and token/cost usage (for OpenAI LLMs and chat models).
-- Logs: Store prompt completion data for each LangChain operation.
-- Dashboard: Combine metrics, logs, and trace data into a single plane to monitor LangChain requests.
-- Monitors: Provide alerts in response to spikes in LangChain request latency or error rate.
-
-Note: The ddtrace LangChain integration currently provides tracing for LLMs, chat models, Text Embedding Models, Chains, and Vectorstores.
-
-## Installation and Setup
-
-1. Enable APM and StatsD in your Datadog Agent, along with a Datadog API key. For example, in Docker:
-
-```
-docker run -d --cgroupns host \
-              --pid host \
-              -v /var/run/docker.sock:/var/run/docker.sock:ro \
-              -v /proc/:/host/proc/:ro \
-              -v /sys/fs/cgroup/:/host/sys/fs/cgroup:ro \
-              -e DD_API_KEY=<DATADOG_API_KEY> \
-              -p 127.0.0.1:8126:8126/tcp \
-              -p 127.0.0.1:8125:8125/udp \
-              -e DD_DOGSTATSD_NON_LOCAL_TRAFFIC=true \
-              -e DD_APM_ENABLED=true \
-              gcr.io/datadoghq/agent:latest
-```
-
-2. Install the Datadog APM Python library.
-
-```
-pip install ddtrace>=1.17
-```
-
-
-3. The LangChain integration can be enabled automatically when you prefix your LangChain Python application command with `ddtrace-run`:
-
-```
-DD_SERVICE="my-service" DD_ENV="staging" DD_API_KEY=<DATADOG_API_KEY> ddtrace-run python <your-app>.py
-```
-
-**Note**: If the Agent is using a non-default hostname or port, be sure to also set `DD_AGENT_HOST`, `DD_TRACE_AGENT_PORT`, or `DD_DOGSTATSD_PORT`.
-
-Additionally, the LangChain integration can be enabled programmatically by adding `patch_all()` or `patch(langchain=True)` before the first import of `langchain` in your application.
-
-Note that using `ddtrace-run` or `patch_all()` will also enable the `requests` and `aiohttp` integrations which trace HTTP requests to LLM providers, as well as the `openai` integration which traces requests to the OpenAI library.
-
-```python
-from ddtrace import config, patch
-
-# Note: be sure to configure the integration before calling ``patch()``!
-# e.g. config.langchain["logs_enabled"] = True
-
-patch(langchain=True)
-
-# to trace synchronous HTTP requests
-# patch(langchain=True, requests=True)
-
-# to trace asynchronous HTTP requests (to the OpenAI library)
-# patch(langchain=True, aiohttp=True)
-
-# to include underlying OpenAI spans from the OpenAI integration
-# patch(langchain=True, openai=True)patch_all
-```
-
-See the [APM Python library documentation](https://ddtrace.readthedocs.io/en/stable/installation_quickstart.html) for more advanced usage.
-
-
-## Configuration
-
-See the [APM Python library documentation](https://ddtrace.readthedocs.io/en/stable/integrations.html#langchain) for all the available configuration options.
-
-
-### Log Prompt & Completion Sampling
-
-To enable log prompt and completion sampling, set the `DD_LANGCHAIN_LOGS_ENABLED=1` environment variable. By default, 10% of traced requests will emit logs containing the prompts and completions.
-
-To adjust the log sample rate, see the [APM library documentation](https://ddtrace.readthedocs.io/en/stable/integrations.html#langchain).
-
-**Note**: Logs submission requires `DD_API_KEY` to be specified when running `ddtrace-run`.
-
-
-## Troubleshooting
-
-Need help? Create an issue on [ddtrace](https://github.com/DataDog/dd-trace-py) or contact [Datadog support](https://docs.datadoghq.com/help/).

langchain_md_files/integrations/providers/datadog_logs.mdx

@@ -1,19 +0,0 @@
-# Datadog Logs
-
->[Datadog](https://www.datadoghq.com/) is a monitoring and analytics platform for cloud-scale applications.
-
-## Installation and Setup
-
-```bash
-pip install datadog_api_client
-```
-
-We must initialize the loader with the Datadog API key and APP key, and we need to set up the query to extract the desired logs.
-
-## Document Loader
-
-See a [usage example](/docs/integrations/document_loaders/datadog_logs).
-
-```python
-from langchain_community.document_loaders import DatadogLogsLoader
-```

langchain_md_files/integrations/providers/dataforseo.mdx

@@ -1,52 +0,0 @@
-# DataForSEO
-
->[DataForSeo](https://dataforseo.com/) provides comprehensive SEO and digital marketing data solutions via API.
-
-This page provides instructions on how to use the DataForSEO search APIs within LangChain.
-
-## Installation and Setup
-
-Get a [DataForSEO API Access login and password](https://app.dataforseo.com/register), and set them as environment variables 
-(`DATAFORSEO_LOGIN` and `DATAFORSEO_PASSWORD` respectively).
-
-```python
-import os
-
-os.environ["DATAFORSEO_LOGIN"] = "your_login"
-os.environ["DATAFORSEO_PASSWORD"] = "your_password"
-```
-
-
-## Utility
-
-The `DataForSEO` utility wraps the API. To import this utility, use:
-
-```python
-from langchain_community.utilities.dataforseo_api_search import DataForSeoAPIWrapper
-```
-
-For a detailed walkthrough of this wrapper, see [this notebook](/docs/integrations/tools/dataforseo).
-
-## Tool
-
-You can also load this wrapper as a Tool to use with an Agent:
-
-```python
-from langchain.agents import load_tools
-tools = load_tools(["dataforseo-api-search"])
-```
-
-This will load the following tools:
-
-```python
-from langchain_community.tools import DataForSeoAPISearchRun
-from langchain_community.tools import DataForSeoAPISearchResults
-```
-
-## Example usage
-
-```python
-dataforseo = DataForSeoAPIWrapper(api_login="your_login", api_password="your_password")
-result = dataforseo.run("Bill Gates")
-print(result)
-```

langchain_md_files/integrations/providers/dataherald.mdx

@@ -1,64 +0,0 @@
-# Dataherald
-
->[Dataherald](https://www.dataherald.com) is a natural language-to-SQL.
-
-This page covers how to use the `Dataherald API` within LangChain.
-
-## Installation and Setup
-- Install requirements with 
-```bash
-pip install dataherald
-```
-- Go to dataherald and sign up [here](https://www.dataherald.com)
-- Create an app and get your `API KEY`
-- Set your `API KEY` as an environment variable `DATAHERALD_API_KEY`
-
-
-## Wrappers
-
-### Utility
-
-There exists a DataheraldAPIWrapper utility which wraps this API. To import this utility:
-
-```python
-from langchain_community.utilities.dataherald import DataheraldAPIWrapper
-```
-
-For a more detailed walkthrough of this wrapper, see [this notebook](/docs/integrations/tools/dataherald).
-
-### Tool
-
-You can use the tool in an agent like this:
-```python
-from langchain_community.utilities.dataherald import DataheraldAPIWrapper
-from langchain_community.tools.dataherald.tool import DataheraldTextToSQL
-from langchain_openai import ChatOpenAI
-from langchain import hub
-from langchain.agents import AgentExecutor, create_react_agent, load_tools
-
-api_wrapper = DataheraldAPIWrapper(db_connection_id="<db_connection_id>")
-tool = DataheraldTextToSQL(api_wrapper=api_wrapper)
-llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
-prompt = hub.pull("hwchase17/react")
-agent = create_react_agent(llm, tools, prompt)
-agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
-agent_executor.invoke({"input":"Return the sql for this question: How many employees are in the company?"})
-```
-
-Output
-```shell
-> Entering new AgentExecutor chain...
-I need to use a tool that can convert this question into SQL.
-Action: dataherald
-Action Input: How many employees are in the company?Answer: SELECT
-    COUNT(*) FROM employeesI now know the final answer
-Final Answer: SELECT
-    COUNT(*)
-FROM
-    employees
-
-> Finished chain.
-{'input': 'Return the sql for this question: How many employees are in the company?', 'output': "SELECT \n    COUNT(*)\nFROM \n    employees"}
-```
-
-For more information on tools, see [this page](/docs/how_to/tools_builtin).

langchain_md_files/integrations/providers/dedoc.mdx

@@ -1,56 +0,0 @@
-# Dedoc
-
->[Dedoc](https://dedoc.readthedocs.io) is an [open-source](https://github.com/ispras/dedoc)
-library/service that extracts texts, tables, attached files and document structure
-(e.g., titles, list items, etc.) from files of various formats.
-
-`Dedoc` supports `DOCX`, `XLSX`, `PPTX`, `EML`, `HTML`, `PDF`, images and more.
-Full list of supported formats can be found [here](https://dedoc.readthedocs.io/en/latest/#id1).
-
-## Installation and Setup
-
-### Dedoc library
-
-You can install `Dedoc` using `pip`.
-In this case, you will need to install dependencies,
-please go [here](https://dedoc.readthedocs.io/en/latest/getting_started/installation.html)
-to get more information.
-
-```bash
-pip install dedoc
-```
-
-### Dedoc API
-
-If you are going to use `Dedoc` API, you don't need to install `dedoc` library.
-In this case, you should run the `Dedoc` service, e.g. `Docker` container (please see
-[the documentation](https://dedoc.readthedocs.io/en/latest/getting_started/installation.html#install-and-run-dedoc-using-docker)
-for more details):
-
-```bash
-docker pull dedocproject/dedoc
-docker run -p 1231:1231
-```
-
-## Document Loader
-
-* For handling files of any formats (supported by `Dedoc`), you can use `DedocFileLoader`:
-
-    ```python
-    from langchain_community.document_loaders import DedocFileLoader
-    ```
-
-* For handling PDF files (with or without a textual layer), you can use `DedocPDFLoader`:
-
-    ```python
-    from langchain_community.document_loaders import DedocPDFLoader
-    ```
-
-* For handling files of any formats without library installation,
-you can use `Dedoc API` with `DedocAPIFileLoader`:
-
-    ```python
-    from langchain_community.document_loaders import DedocAPIFileLoader
-    ```
-
-Please see a [usage example](/docs/integrations/document_loaders/dedoc) for more details.

langchain_md_files/integrations/providers/deepinfra.mdx

@@ -1,53 +0,0 @@
-# DeepInfra
-
->[DeepInfra](https://deepinfra.com/docs) allows us to run the 
-> [latest machine learning models](https://deepinfra.com/models) with ease. 
-> DeepInfra takes care of all the heavy lifting related to running, scaling and monitoring 
-> the models. Users can focus on your application and integrate the models with simple REST API calls.
-
->DeepInfra provides [examples](https://deepinfra.com/docs/advanced/langchain) of integration with LangChain.
-
-This page covers how to use the `DeepInfra` ecosystem within `LangChain`.
-It is broken into two parts: installation and setup, and then references to specific DeepInfra wrappers.
-
-## Installation and Setup
-
-- Get your DeepInfra api key from this link [here](https://deepinfra.com/).
-- Get an DeepInfra api key and set it as an environment variable (`DEEPINFRA_API_TOKEN`)
-
-## Available Models
-
-DeepInfra provides a range of Open Source LLMs ready for deployment.
-
-You can see supported models for
-[text-generation](https://deepinfra.com/models?type=text-generation) and
-[embeddings](https://deepinfra.com/models?type=embeddings).
-
-You can view a [list of request and response parameters](https://deepinfra.com/meta-llama/Llama-2-70b-chat-hf/api).
-
-Chat models [follow openai api](https://deepinfra.com/meta-llama/Llama-2-70b-chat-hf/api?example=openai-http)
-
-
-## LLM
-
-See a [usage example](/docs/integrations/llms/deepinfra).
-
-```python
-from langchain_community.llms import DeepInfra
-```
-
-## Embeddings
-
-See a [usage example](/docs/integrations/text_embedding/deepinfra).
-
-```python
-from langchain_community.embeddings import DeepInfraEmbeddings
-```
-
-## Chat Models
-
-See a [usage example](/docs/integrations/chat/deepinfra).
-
-```python
-from langchain_community.chat_models import ChatDeepInfra
-```

langchain_md_files/integrations/providers/deepsparse.mdx

@@ -1,34 +0,0 @@
-# DeepSparse
-
-This page covers how to use the [DeepSparse](https://github.com/neuralmagic/deepsparse) inference runtime within LangChain.
-It is broken into two parts: installation and setup, and then examples of DeepSparse usage.
-
-## Installation and Setup
-
-- Install the Python package with `pip install deepsparse`
-- Choose a [SparseZoo model](https://sparsezoo.neuralmagic.com/?useCase=text_generation) or export a support model to ONNX [using Optimum](https://github.com/neuralmagic/notebooks/blob/main/notebooks/opt-text-generation-deepsparse-quickstart/OPT_Text_Generation_DeepSparse_Quickstart.ipynb)
-
-
-## LLMs
-
-There exists a DeepSparse LLM wrapper, which you can access with:
-
-```python
-from langchain_community.llms import DeepSparse
-```
-
-It provides a unified interface for all models:
-
-```python
-llm = DeepSparse(model='zoo:nlg/text_generation/codegen_mono-350m/pytorch/huggingface/bigpython_bigquery_thepile/base-none')
-
-print(llm.invoke('def fib():'))
-```
-
-Additional parameters can be passed using the `config` parameter:
-
-```python
-config = {'max_generated_tokens': 256}
-
-llm = DeepSparse(model='zoo:nlg/text_generation/codegen_mono-350m/pytorch/huggingface/bigpython_bigquery_thepile/base-none', config=config)
-```

langchain_md_files/integrations/providers/diffbot.mdx

@@ -1,29 +0,0 @@
-# Diffbot
-
-> [Diffbot](https://docs.diffbot.com/docs) is a suite of ML-based products that make it easy to structure and integrate web data.
-
-## Installation and Setup
-
-[Get a free Diffbot API token](https://app.diffbot.com/get-started/) and [follow these instructions](https://docs.diffbot.com/reference/authentication) to authenticate your requests.
-
-## Document Loader
-
-Diffbot's [Extract API](https://docs.diffbot.com/reference/extract-introduction) is a service that structures and normalizes data from web pages. 
-
-Unlike traditional web scraping tools, `Diffbot Extract` doesn't require any rules to read the content on a page. It uses a computer vision model to classify a page into one of 20 possible types, and then transforms raw HTML markup into JSON. The resulting structured JSON follows a consistent [type-based ontology](https://docs.diffbot.com/docs/ontology), which makes it easy to extract data from multiple different web sources with the same schema. 
-
-See a [usage example](/docs/integrations/document_loaders/diffbot).
-
-```python
-from langchain_community.document_loaders import DiffbotLoader
-```
-
-## Graphs
-
-Diffbot's [Natural Language Processing API](https://www.diffbot.com/products/natural-language/) allows for the extraction of entities, relationships, and semantic meaning from unstructured text data.
-
-See a [usage example](/docs/integrations/graphs/diffbot).
-
-```python
-from langchain_experimental.graph_transformers.diffbot import DiffbotGraphTransformer
-```