421f803355974a702f7603a70074546b87af62b9a352b2c06bd834024cd5af7b

langchain_md_files/integrations/providers/dingo.mdx

@@ -0,0 +1,31 @@
+# DingoDB
+
+>[DingoDB](https://github.com/dingodb) is a distributed multi-modal vector 
+> database. It combines the features of a data lake and a vector database, 
+> allowing for the storage of any type of data (key-value, PDF, audio, 
+> video, etc.) regardless of its size. Utilizing DingoDB, you can construct 
+> your own Vector Ocean (the next-generation data architecture following data 
+> warehouse and data lake). This enables 
+> the analysis of both structured and unstructured data through 
+> a singular SQL with exceptionally low latency in real time.
+
+## Installation and Setup
+
+Install the Python SDK
+
+```bash
+pip install dingodb
+```
+
+## VectorStore
+
+There exists a wrapper around DingoDB indexes, allowing you to use it as a vectorstore,
+whether for semantic search or example selection.
+
+To import this vectorstore:
+
+```python
+from langchain_community.vectorstores import Dingo
+```
+
+For a more detailed walkthrough of the DingoDB wrapper, see [this notebook](/docs/integrations/vectorstores/dingo)

langchain_md_files/integrations/providers/discord.mdx

@@ -0,0 +1,38 @@
+# Discord
+
+>[Discord](https://discord.com/) is a VoIP and instant messaging social platform. Users have the ability to communicate 
+> with voice calls, video calls, text messaging, media and files in private chats or as part of communities called 
+> "servers". A server is a collection of persistent chat rooms and voice channels which can be accessed via invite links.
+
+## Installation and Setup
+
+```bash
+pip install pandas
+```
+
+Follow these steps to download your `Discord` data:
+
+1. Go to your **User Settings**
+2. Then go to **Privacy and Safety**
+3. Head over to the **Request all of my Data** and click on **Request Data** button
+
+It might take 30 days for you to receive your data. You'll receive an email at the address which is registered 
+with Discord. That email will have a download button using which you would be able to download your personal Discord data.
+
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/discord).
+
+**NOTE:** The  `DiscordChatLoader` is not the `ChatLoader` but a `DocumentLoader`. 
+It is used to load the data from the `Discord` data dump.
+For the `ChatLoader` see Chat Loader section below.
+
+```python
+from langchain_community.document_loaders import DiscordChatLoader
+```
+
+## Chat Loader
+
+See a [usage example](/docs/integrations/chat_loaders/discord).
+

langchain_md_files/integrations/providers/docarray.mdx

@@ -0,0 +1,37 @@
+# DocArray
+
+> [DocArray](https://docarray.jina.ai/) is a library for nested, unstructured, multimodal data in transit, 
+> including text, image, audio, video, 3D mesh, etc. It allows deep-learning engineers to efficiently process, 
+> embed, search, recommend, store, and transfer multimodal data with a Pythonic API.
+
+
+## Installation and Setup
+
+We need to install `docarray` python package.
+
+```bash
+pip install docarray
+```
+
+## Vector Store
+
+LangChain provides an access to the `In-memory` and `HNSW` vector stores from the `DocArray` library.
+
+See a [usage example](/docs/integrations/vectorstores/docarray_hnsw).
+
+```python
+from langchain_community.vectorstores import DocArrayHnswSearch
+```
+See a [usage example](/docs/integrations/vectorstores/docarray_in_memory).
+
+```python
+from langchain_community.vectorstores DocArrayInMemorySearch
+```
+
+## Retriever
+
+See a [usage example](/docs/integrations/retrievers/docarray_retriever).
+
+```python
+from langchain_community.retrievers import DocArrayRetriever
+```

langchain_md_files/integrations/providers/doctran.mdx

@@ -0,0 +1,37 @@
+# Doctran
+
+>[Doctran](https://github.com/psychic-api/doctran) is a python package. It uses LLMs and open-source 
+> NLP libraries to transform raw text into clean, structured, information-dense documents 
+> that are optimized for vector space retrieval. You can think of `Doctran` as a black box where 
+> messy strings go in and nice, clean, labelled strings come out.
+
+
+## Installation and Setup
+
+```bash
+pip install doctran
+```
+
+## Document Transformers
+
+### Document Interrogator
+
+See a [usage example for DoctranQATransformer](/docs/integrations/document_transformers/doctran_interrogate_document).
+
+```python
+from langchain_community.document_loaders import DoctranQATransformer
+```
+### Property Extractor
+
+See a [usage example for DoctranPropertyExtractor](/docs/integrations/document_transformers/doctran_extract_properties).
+
+```python
+from langchain_community.document_loaders import DoctranPropertyExtractor
+```
+### Document Translator
+
+See a [usage example for DoctranTextTranslator](/docs/integrations/document_transformers/doctran_translate_document).
+
+```python
+from langchain_community.document_loaders import DoctranTextTranslator
+```

langchain_md_files/integrations/providers/docugami.mdx

@@ -0,0 +1,21 @@
+# Docugami
+
+>[Docugami](https://docugami.com) converts business documents into a Document XML Knowledge Graph, generating forests 
+> of XML semantic trees representing entire documents. This is a rich representation that includes the semantic and 
+> structural characteristics of various chunks in the document as an XML tree.
+
+## Installation and Setup
+
+
+```bash
+pip install dgml-utils
+pip install docugami-langchain
+```
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/docugami).
+
+```python
+from docugami_langchain.document_loaders import DocugamiLoader
+```

langchain_md_files/integrations/providers/docusaurus.mdx

@@ -0,0 +1,20 @@
+# Docusaurus
+
+>[Docusaurus](https://docusaurus.io/) is a static-site generator which provides 
+> out-of-the-box documentation features.
+ 
+
+## Installation and Setup
+
+
+```bash
+pip install -U beautifulsoup4 lxml
+```
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/docusaurus).
+
+```python
+from langchain_community.document_loaders import DocusaurusLoader
+```

langchain_md_files/integrations/providers/dria.mdx

@@ -0,0 +1,25 @@
+# Dria
+
+>[Dria](https://dria.co/) is a hub of public RAG models for developers to 
+> both contribute and utilize a shared embedding lake.
+
+See more details about the LangChain integration with Dria 
+at [this page](https://dria.co/docs/integrations/langchain).
+
+## Installation and Setup
+
+You have to install a python package:
+
+```bash
+pip install dria
+```
+
+You have to get an API key from Dria. You can get it by signing up at [Dria](https://dria.co/).
+
+## Retrievers
+
+See a [usage example](/docs/integrations/retrievers/dria_index).
+
+```python
+from langchain_community.retrievers import DriaRetriever
+```

langchain_md_files/integrations/providers/dropbox.mdx

@@ -0,0 +1,21 @@
+# Dropbox
+
+>[Dropbox](https://en.wikipedia.org/wiki/Dropbox) is a file hosting service that brings everything-traditional 
+> files, cloud content, and web shortcuts together in one place.
+ 
+
+## Installation and Setup
+
+See the detailed [installation guide](/docs/integrations/document_loaders/dropbox#prerequisites).
+
+```bash
+pip install -U dropbox
+```
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/dropbox).
+
+```python
+from langchain_community.document_loaders import DropboxLoader
+```

langchain_md_files/integrations/providers/duckdb.mdx

@@ -0,0 +1,19 @@
+# DuckDB
+
+>[DuckDB](https://duckdb.org/) is an in-process SQL OLAP database management system.
+
+## Installation and Setup
+
+First, you need to install `duckdb` python package.
+
+```bash
+pip install duckdb
+```
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/duckdb).
+
+```python
+from langchain_community.document_loaders import DuckDBLoader
+```

langchain_md_files/integrations/providers/duckduckgo_search.mdx

@@ -0,0 +1,25 @@
+# DuckDuckGo Search
+
+>[DuckDuckGo Search](https://github.com/deedy5/duckduckgo_search) is a package that
+> searches for words, documents, images, videos, news, maps and text
+> translation using the `DuckDuckGo.com` search engine. It is downloading files 
+> and images to a local hard drive.
+
+## Installation and Setup
+
+You have to install a python package:
+
+```bash
+pip install duckduckgo-search
+```
+
+## Tools
+
+See a [usage example](/docs/integrations/tools/ddg).
+
+There are two tools available:
+
+```python
+from langchain_community.tools import DuckDuckGoSearchRun
+from langchain_community.tools import DuckDuckGoSearchResults
+```

langchain_md_files/integrations/providers/e2b.mdx

@@ -0,0 +1,20 @@
+# E2B
+
+>[E2B](https://e2b.dev/) provides open-source secure sandboxes 
+> for AI-generated code execution. See more [here](https://github.com/e2b-dev).
+
+## Installation and Setup
+
+You have to install a python package:
+
+```bash
+pip install e2b_code_interpreter
+```
+
+## Tool
+
+See a [usage example](/docs/integrations/tools/e2b_data_analysis).
+
+```python
+from langchain_community.tools import E2BDataAnalysisTool
+```

langchain_md_files/integrations/providers/edenai.mdx

@@ -0,0 +1,62 @@
+# Eden AI
+
+>[Eden AI](https://docs.edenai.co/docs/getting-started-with-eden-ai) user interface (UI) 
+> is designed for handling the AI projects. With `Eden AI Portal`, 
+> you can perform no-code AI using the best engines for the market.
+
+
+## Installation and Setup
+
+Accessing the Eden AI API requires an API key, which you can get by 
+[creating an account](https://app.edenai.run/user/register) and 
+heading [here](https://app.edenai.run/admin/account/settings). 
+
+## LLMs
+
+See a [usage example](/docs/integrations/llms/edenai).
+
+```python
+from langchain_community.llms import EdenAI
+
+```
+
+## Chat models
+
+See a [usage example](/docs/integrations/chat/edenai).
+
+```python
+from langchain_community.chat_models.edenai import ChatEdenAI
+```
+
+## Embedding models
+
+See a [usage example](/docs/integrations/text_embedding/edenai).
+
+```python
+from langchain_community.embeddings.edenai import EdenAiEmbeddings
+```
+
+## Tools
+
+Eden AI provides a list of tools that grants your Agent the ability to do multiple tasks, such as:
+* speech to text
+* text to speech
+* text explicit content detection
+* image explicit content detection
+* object detection
+* OCR invoice parsing
+* OCR ID parsing
+
+See a [usage example](/docs/integrations/tools/edenai_tools).
+
+```python
+from langchain_community.tools.edenai import (
+    EdenAiExplicitImageTool,
+    EdenAiObjectDetectionTool,
+    EdenAiParsingIDTool,
+    EdenAiParsingInvoiceTool,
+    EdenAiSpeechToTextTool,
+    EdenAiTextModerationTool,
+    EdenAiTextToSpeechTool,
+)
+```

langchain_md_files/integrations/providers/elasticsearch.mdx

@@ -0,0 +1,108 @@
+# Elasticsearch
+
+> [Elasticsearch](https://www.elastic.co/elasticsearch/) is a distributed, RESTful search and analytics engine.
+> It provides a distributed, multi-tenant-capable full-text search engine with an HTTP web interface and schema-free
+> JSON documents.
+
+## Installation and Setup
+
+### Setup Elasticsearch
+
+There are two ways to get started with Elasticsearch:
+
+#### Install Elasticsearch on your local machine via Docker
+
+Example: Run a single-node Elasticsearch instance with security disabled. 
+This is not recommended for production use.
+
+```bash
+    docker run -p 9200:9200 -e "discovery.type=single-node" -e "xpack.security.enabled=false" -e "xpack.security.http.ssl.enabled=false" docker.elastic.co/elasticsearch/elasticsearch:8.9.0
+```
+
+#### Deploy Elasticsearch on Elastic Cloud
+
+`Elastic Cloud` is a managed Elasticsearch service. Signup for a [free trial](https://cloud.elastic.co/registration?utm_source=langchain&utm_content=documentation).
+
+### Install Client
+
+```bash
+pip install elasticsearch
+pip install langchain-elasticsearch
+```
+
+## Embedding models
+
+See a [usage example](/docs/integrations/text_embedding/elasticsearch).
+
+```python
+from langchain_elasticsearch import ElasticsearchEmbeddings
+```
+
+## Vector store
+
+See a [usage example](/docs/integrations/vectorstores/elasticsearch).
+
+```python
+from langchain_elasticsearch import ElasticsearchStore
+```
+
+### Third-party integrations
+
+#### EcloudESVectorStore
+
+```python
+from langchain_community.vectorstores.ecloud_vector_search import EcloudESVectorStore
+```
+
+## Retrievers
+
+### ElasticsearchRetriever
+
+The `ElasticsearchRetriever` enables flexible access to all Elasticsearch features 
+through the Query DSL. 
+
+See a [usage example](/docs/integrations/retrievers/elasticsearch_retriever).
+
+```python
+from langchain_elasticsearch import ElasticsearchRetriever
+```
+
+### BM25
+
+See a [usage example](/docs/integrations/retrievers/elastic_search_bm25).
+
+```python
+from langchain_community.retrievers import ElasticSearchBM25Retriever
+```
+## Memory
+
+See a [usage example](/docs/integrations/memory/elasticsearch_chat_message_history).
+
+```python
+from langchain_elasticsearch import ElasticsearchChatMessageHistory
+```
+
+## LLM cache
+
+See a [usage example](/docs/integrations/llm_caching/#elasticsearch-cache).
+
+```python
+from langchain_elasticsearch import ElasticsearchCache
+```
+
+## Byte Store
+
+See a [usage example](/docs/integrations/stores/elasticsearch).
+
+```python
+from langchain_elasticsearch import ElasticsearchEmbeddingsCache
+```
+
+## Chain
+
+It is a chain for interacting with Elasticsearch Database.
+
+```python
+from langchain.chains.elasticsearch_database import ElasticsearchDatabaseChain
+```
+

langchain_md_files/integrations/providers/elevenlabs.mdx

@@ -0,0 +1,27 @@
+# ElevenLabs
+
+>[ElevenLabs](https://elevenlabs.io/about) is a voice AI research & deployment company 
+> with a mission to make content universally accessible in any language & voice.
+>
+>`ElevenLabs` creates the most realistic, versatile and contextually-aware 
+> AI audio, providing the ability to generate speech in hundreds of 
+> new and existing voices in 29 languages.
+
+## Installation and Setup
+
+First, you need to set up an ElevenLabs account. You can follow the 
+[instructions here](https://docs.elevenlabs.io/welcome/introduction).
+
+Install the Python package:
+
+```bash
+pip install elevenlabs
+```
+
+## Tools
+
+See a [usage example](/docs/integrations/tools/eleven_labs_tts).
+
+```python
+from langchain_community.tools import ElevenLabsText2SpeechTool
+```

langchain_md_files/integrations/providers/epsilla.mdx

@@ -0,0 +1,23 @@
+# Epsilla
+
+This page covers how to use [Epsilla](https://github.com/epsilla-cloud/vectordb) within LangChain.
+It is broken into two parts: installation and setup, and then references to specific Epsilla wrappers.
+
+## Installation and Setup
+
+- Install the Python SDK with `pip/pip3 install pyepsilla`
+
+## Wrappers
+
+### VectorStore
+
+There exists a wrapper around Epsilla vector databases, allowing you to use it as a vectorstore,
+whether for semantic search or example selection.
+
+To import this vectorstore:
+
+```python
+from langchain_community.vectorstores import Epsilla
+```
+
+For a more detailed walkthrough of the Epsilla wrapper, see [this notebook](/docs/integrations/vectorstores/epsilla)

langchain_md_files/integrations/providers/etherscan.mdx

@@ -0,0 +1,18 @@
+# Etherscan
+
+>[Etherscan](https://docs.etherscan.io/) is the leading blockchain explorer, 
+> search, API and analytics platform for `Ethereum`, a decentralized smart contracts platform.
+ 
+
+## Installation and Setup
+
+See the detailed [installation guide](/docs/integrations/document_loaders/etherscan).
+
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/etherscan).
+
+```python
+from langchain_community.document_loaders import EtherscanLoader
+```

langchain_md_files/integrations/providers/evernote.mdx

@@ -0,0 +1,20 @@
+# EverNote
+
+>[EverNote](https://evernote.com/) is intended for archiving and creating notes in which photos, audio and saved web content can be embedded. Notes are stored in virtual "notebooks" and can be tagged, annotated, edited, searched, and exported.
+
+## Installation and Setup
+
+First, you need to install `lxml` and `html2text` python packages.
+
+```bash
+pip install lxml
+pip install html2text
+```
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/evernote).
+
+```python
+from langchain_community.document_loaders import EverNoteLoader
+```

langchain_md_files/integrations/providers/facebook.mdx

@@ -0,0 +1,93 @@
+# Facebook - Meta
+
+>[Meta Platforms, Inc.](https://www.facebook.com/), doing business as `Meta`, formerly 
+> named `Facebook, Inc.`, and `TheFacebook, Inc.`, is an American multinational technology 
+> conglomerate. The company owns and operates `Facebook`, `Instagram`, `Threads`, 
+> and `WhatsApp`, among other products and services.
+ 
+## Embedding models
+
+### LASER
+
+>[LASER](https://github.com/facebookresearch/LASER) is a Python library developed by 
+> the `Meta AI Research` team and used for 
+> creating multilingual sentence embeddings for 
+> [over 147 languages as of 2/25/2024](https://github.com/facebookresearch/flores/blob/main/flores200/README.md#languages-in-flores-200) 
+
+```bash
+pip install laser_encoders
+```
+
+See a [usage example](/docs/integrations/text_embedding/laser).
+
+```python
+from langchain_community.embeddings.laser import LaserEmbeddings
+```
+
+## Document loaders
+
+### Facebook Messenger
+
+>[Messenger](https://en.wikipedia.org/wiki/Messenger_(software)) is an instant messaging app and 
+> platform developed by `Meta Platforms`. Originally developed as `Facebook Chat` in 2008, the company revamped its
+> messaging service in 2010.
+
+See a [usage example](/docs/integrations/document_loaders/facebook_chat).
+
+```python
+from langchain_community.document_loaders import FacebookChatLoader
+```
+
+## Vector stores
+
+### Facebook Faiss
+
+>[Facebook AI Similarity Search (Faiss)](https://engineering.fb.com/2017/03/29/data-infrastructure/faiss-a-library-for-efficient-similarity-search/) 
+> is a library for efficient similarity search and clustering of dense vectors. It contains algorithms that 
+> search in sets of vectors of any size, up to ones that possibly do not fit in RAM. It also contains supporting 
+> code for evaluation and parameter tuning.
+
+[Faiss documentation](https://faiss.ai/).
+
+We need to install `faiss` python package.
+
+```bash
+pip install faiss-gpu # For CUDA 7.5+ supported GPU's.
+```
+
+OR
+
+```bash
+pip install faiss-cpu # For CPU Installation
+```
+
+See a [usage example](/docs/integrations/vectorstores/faiss).
+
+```python
+from langchain_community.vectorstores import FAISS
+```
+
+## Chat loaders
+
+### Facebook Messenger
+
+>[Messenger](https://en.wikipedia.org/wiki/Messenger_(software)) is an instant messaging app and 
+> platform developed by `Meta Platforms`. Originally developed as `Facebook Chat` in 2008, the company revamped its
+> messaging service in 2010.
+
+See a [usage example](/docs/integrations/chat_loaders/facebook).
+
+```python
+from langchain_community.chat_loaders.facebook_messenger import (
+    FolderFacebookMessengerChatLoader,
+    SingleFileFacebookMessengerChatLoader,
+)
+```
+
+### Facebook WhatsApp
+
+See a [usage example](/docs/integrations/chat_loaders/whatsapp).
+
+```python
+from langchain_community.chat_loaders.whatsapp import WhatsAppChatLoader
+```

langchain_md_files/integrations/providers/fauna.mdx

@@ -0,0 +1,25 @@
+# Fauna
+
+>[Fauna](https://fauna.com/) is a distributed document-relational database 
+> that combines the flexibility of documents with the power of a relational, 
+> ACID compliant database that scales across regions, clouds or the globe.
+ 
+
+## Installation and Setup
+
+We have to get the secret key.
+See the detailed [guide](https://docs.fauna.com/fauna/current/learn/security_model/).
+
+We have to install the `fauna` package.
+
+```bash
+pip install -U fauna
+```
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/fauna).
+
+```python
+from langchain_community.document_loaders.fauna import FaunaLoader
+```

langchain_md_files/integrations/providers/figma.mdx

@@ -0,0 +1,21 @@
+# Figma
+
+>[Figma](https://www.figma.com/) is a collaborative web application for interface design.
+
+## Installation and Setup
+
+The Figma API requires an `access token`, `node_ids`, and a `file key`.
+
+The `file key` can be pulled from the URL.  https://www.figma.com/file/{filekey}/sampleFilename
+
+`Node IDs` are also available in the URL. Click on anything and look for the '?node-id={node_id}' param.
+
+`Access token` [instructions](https://help.figma.com/hc/en-us/articles/8085703771159-Manage-personal-access-tokens).
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/figma).
+
+```python
+from langchain_community.document_loaders import FigmaFileLoader
+```

langchain_md_files/integrations/providers/flyte.mdx

@@ -0,0 +1,153 @@
+# Flyte
+
+> [Flyte](https://github.com/flyteorg/flyte) is an open-source orchestrator that facilitates building production-grade data and ML pipelines.
+> It is built for scalability and reproducibility, leveraging Kubernetes as its underlying platform.
+
+The purpose of this notebook is to demonstrate the integration of a `FlyteCallback` into your Flyte task, enabling you to effectively monitor and track your LangChain experiments.
+
+## Installation & Setup
+
+- Install the Flytekit library by running the command `pip install flytekit`.
+- Install the Flytekit-Envd plugin by running the command `pip install flytekitplugins-envd`.
+- Install LangChain by running the command `pip install langchain`.
+- Install [Docker](https://docs.docker.com/engine/install/) on your system.
+
+## Flyte Tasks
+
+A Flyte [task](https://docs.flyte.org/en/latest/user_guide/basics/tasks.html) serves as the foundational building block of Flyte.
+To execute LangChain experiments, you need to write Flyte tasks that define the specific steps and operations involved.
+
+NOTE: The [getting started guide](https://docs.flyte.org/projects/cookbook/en/latest/index.html) offers detailed, step-by-step instructions on installing Flyte locally and running your initial Flyte pipeline.
+
+First, import the necessary dependencies to support your LangChain experiments.
+
+```python
+import os
+
+from flytekit import ImageSpec, task
+from langchain.agents import AgentType, initialize_agent, load_tools
+from langchain.callbacks import FlyteCallbackHandler
+from langchain.chains import LLMChain
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import PromptTemplate
+from langchain_core.messages import HumanMessage
+```
+
+Set up the necessary environment variables to utilize the OpenAI API and Serp API:
+
+```python
+# Set OpenAI API key
+os.environ["OPENAI_API_KEY"] = "<your_openai_api_key>"
+
+# Set Serp API key
+os.environ["SERPAPI_API_KEY"] = "<your_serp_api_key>"
+```
+
+Replace `<your_openai_api_key>` and `<your_serp_api_key>` with your respective API keys obtained from OpenAI and Serp API.
+
+To guarantee reproducibility of your pipelines, Flyte tasks are containerized.
+Each Flyte task must be associated with an image, which can either be shared across the entire Flyte [workflow](https://docs.flyte.org/en/latest/user_guide/basics/workflows.html) or provided separately for each task.
+
+To streamline the process of supplying the required dependencies for each Flyte task, you can initialize an [`ImageSpec`](https://docs.flyte.org/en/latest/user_guide/customizing_dependencies/imagespec.html) object.
+This approach automatically triggers a Docker build, alleviating the need for users to manually create a Docker image.
+
+```python
+custom_image = ImageSpec(
+    name="langchain-flyte",
+    packages=[
+        "langchain",
+        "openai",
+        "spacy",
+        "https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.5.0/en_core_web_sm-3.5.0.tar.gz",
+        "textstat",
+        "google-search-results",
+    ],
+    registry="<your-registry>",
+)
+```
+
+You have the flexibility to push the Docker image to a registry of your preference.
+[Docker Hub](https://hub.docker.com/) or [GitHub Container Registry (GHCR)](https://docs.github.com/en/packages/working-with-a-github-packages-registry/working-with-the-container-registry) is a convenient option to begin with.
+
+Once you have selected a registry, you can proceed to create Flyte tasks that log the LangChain metrics to Flyte Deck.
+
+The following examples demonstrate tasks related to OpenAI LLM, chains and agent with tools:
+
+### LLM
+
+```python
+@task(disable_deck=False, container_image=custom_image)
+def langchain_llm() -> str:
+    llm = ChatOpenAI(
+        model_name="gpt-3.5-turbo",
+        temperature=0.2,
+        callbacks=[FlyteCallbackHandler()],
+    )
+    return llm.invoke([HumanMessage(content="Tell me a joke")]).content
+```
+
+### Chain
+
+```python
+@task(disable_deck=False, container_image=custom_image)
+def langchain_chain() -> list[dict[str, str]]:
+    template = """You are a playwright. Given the title of play, it is your job to write a synopsis for that title.
+Title: {title}
+Playwright: This is a synopsis for the above play:"""
+    llm = ChatOpenAI(
+        model_name="gpt-3.5-turbo",
+        temperature=0,
+        callbacks=[FlyteCallbackHandler()],
+    )
+    prompt_template = PromptTemplate(input_variables=["title"], template=template)
+    synopsis_chain = LLMChain(
+        llm=llm, prompt=prompt_template, callbacks=[FlyteCallbackHandler()]
+    )
+    test_prompts = [
+        {
+            "title": "documentary about good video games that push the boundary of game design"
+        },
+    ]
+    return synopsis_chain.apply(test_prompts)
+```
+
+### Agent
+
+```python
+@task(disable_deck=False, container_image=custom_image)
+def langchain_agent() -> str:
+    llm = OpenAI(
+        model_name="gpt-3.5-turbo",
+        temperature=0,
+        callbacks=[FlyteCallbackHandler()],
+    )
+    tools = load_tools(
+        ["serpapi", "llm-math"], llm=llm, callbacks=[FlyteCallbackHandler()]
+    )
+    agent = initialize_agent(
+        tools,
+        llm,
+        agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
+        callbacks=[FlyteCallbackHandler()],
+        verbose=True,
+    )
+    return agent.run(
+        "Who is Leonardo DiCaprio's girlfriend? Could you calculate her current age and raise it to the power of 0.43?"
+    )
+```
+
+These tasks serve as a starting point for running your LangChain experiments within Flyte.
+
+## Execute the Flyte Tasks on Kubernetes
+
+To execute the Flyte tasks on the configured Flyte backend, use the following command:
+
+```bash
+pyflyte run --image <your-image> langchain_flyte.py langchain_llm
+```
+
+This command will initiate the execution of the `langchain_llm` task on the Flyte backend. You can trigger the remaining two tasks in a similar manner.
+
+The metrics will be displayed on the Flyte UI as follows:
+
+![Screenshot of Flyte Deck showing LangChain metrics and a dependency tree visualization.](https://ik.imagekit.io/c8zl7irwkdda/Screenshot_2023-06-20_at_1.23.29_PM_MZYeG0dKa.png?updatedAt=1687247642993 "Flyte Deck Metrics Display")

langchain_md_files/integrations/providers/forefrontai.mdx

@@ -0,0 +1,16 @@
+# ForefrontAI
+
+This page covers how to use the ForefrontAI ecosystem within LangChain.
+It is broken into two parts: installation and setup, and then references to specific ForefrontAI wrappers.
+
+## Installation and Setup
+- Get an ForefrontAI api key and set it as an environment variable (`FOREFRONTAI_API_KEY`)
+
+## Wrappers
+
+### LLM
+
+There exists an ForefrontAI LLM wrapper, which you can access with 
+```python
+from langchain_community.llms import ForefrontAI
+```

langchain_md_files/integrations/providers/geopandas.mdx

@@ -0,0 +1,23 @@
+# Geopandas
+
+>[GeoPandas](https://geopandas.org/) is an open source project to make working 
+> with geospatial data in python easier. `GeoPandas` extends the datatypes used by 
+> `pandas` to allow spatial operations on geometric types. 
+> Geometric operations are performed by `shapely`.
+ 
+
+## Installation and Setup
+
+We have to install several python packages.
+
+```bash
+pip install -U sodapy pandas geopandas
+```
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/geopandas).
+
+```python
+from langchain_community.document_loaders import OpenCityDataLoader
+```

langchain_md_files/integrations/providers/git.mdx

@@ -0,0 +1,19 @@
+# Git
+
+>[Git](https://en.wikipedia.org/wiki/Git) is a distributed version control system that tracks changes in any set of computer files, usually used for coordinating work among programmers collaboratively developing source code during software development.
+
+## Installation and Setup
+
+First, you need to install `GitPython` python package.
+
+```bash
+pip install GitPython
+```
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/git).
+
+```python
+from langchain_community.document_loaders import GitLoader
+```

langchain_md_files/integrations/providers/gitbook.mdx

@@ -0,0 +1,15 @@
+# GitBook
+
+>[GitBook](https://docs.gitbook.com/) is a modern documentation platform where teams can document everything from products to internal knowledge bases and APIs.
+
+## Installation and Setup
+
+There isn't any special setup for it.
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/gitbook).
+
+```python
+from langchain_community.document_loaders import GitbookLoader
+```

langchain_md_files/integrations/providers/github.mdx

@@ -0,0 +1,22 @@
+# GitHub
+
+>[GitHub](https://github.com/) is a developer platform that allows developers to create, 
+> store, manage and share their code. It uses `Git` software, providing the 
+> distributed version control of Git plus access control, bug tracking, 
+> software feature requests, task management, continuous integration, and wikis for every project.
+ 
+
+## Installation and Setup
+
+To access the GitHub API, you need a [personal access token](https://github.com/settings/tokens).
+
+
+## Document Loader
+
+There are two document loaders available for GitHub.
+
+See a [usage example](/docs/integrations/document_loaders/github).
+
+```python
+from langchain_community.document_loaders import GitHubIssuesLoader, GithubFileLoader
+```

langchain_md_files/integrations/providers/golden.mdx

@@ -0,0 +1,34 @@
+# Golden
+
+>[Golden](https://golden.com) provides a set of natural language APIs for querying and enrichment using the Golden Knowledge Graph e.g. queries such as: `Products from OpenAI`, `Generative ai companies with series a funding`, and `rappers who invest` can be used to retrieve structured data about relevant entities.
+>
+>The `golden-query` langchain tool is a wrapper on top of the [Golden Query API](https://docs.golden.com/reference/query-api) which enables programmatic access to these results.
+>See the [Golden Query API docs](https://docs.golden.com/reference/query-api) for more information.
+
+## Installation and Setup
+- Go to the [Golden API docs](https://docs.golden.com/) to get an overview about the Golden API.
+- Get your API key from the [Golden API Settings](https://golden.com/settings/api) page.
+- Save your API key into GOLDEN_API_KEY env variable
+
+## Wrappers
+
+### Utility
+
+There exists a GoldenQueryAPIWrapper utility which wraps this API. To import this utility:
+
+```python
+from langchain_community.utilities.golden_query import GoldenQueryAPIWrapper
+```
+
+For a more detailed walkthrough of this wrapper, see [this notebook](/docs/integrations/tools/golden_query).
+
+### Tool
+
+You can also easily load this wrapper as a Tool (to use with an Agent).
+You can do this with:
+```python
+from langchain.agents import load_tools
+tools = load_tools(["golden-query"])
+```
+
+For more information on tools, see [this page](/docs/how_to/tools_builtin).

langchain_md_files/integrations/providers/google_serper.mdx

@@ -0,0 +1,74 @@
+# Serper - Google Search API
+
+This page covers how to use the [Serper](https://serper.dev) Google Search API within LangChain. Serper is a low-cost Google Search API that can be used to add answer box, knowledge graph, and organic results data from Google Search. 
+It is broken into two parts: setup, and then references to the specific Google Serper wrapper.
+
+## Setup
+
+- Go to [serper.dev](https://serper.dev) to sign up for a free account
+- Get the api key and set it as an environment variable (`SERPER_API_KEY`)
+
+## Wrappers
+
+### Utility
+
+There exists a GoogleSerperAPIWrapper utility which wraps this API. To import this utility:
+
+```python
+from langchain_community.utilities import GoogleSerperAPIWrapper
+```
+
+You can use it as part of a Self Ask chain:
+
+```python
+from langchain_community.utilities import GoogleSerperAPIWrapper
+from langchain_openai import OpenAI
+from langchain.agents import initialize_agent, Tool
+from langchain.agents import AgentType
+
+import os
+
+os.environ["SERPER_API_KEY"] = ""
+os.environ['OPENAI_API_KEY'] = ""
+
+llm = OpenAI(temperature=0)
+search = GoogleSerperAPIWrapper()
+tools = [
+    Tool(
+        name="Intermediate Answer",
+        func=search.run,
+        description="useful for when you need to ask with search"
+    )
+]
+
+self_ask_with_search = initialize_agent(tools, llm, agent=AgentType.SELF_ASK_WITH_SEARCH, verbose=True)
+self_ask_with_search.run("What is the hometown of the reigning men's U.S. Open champion?")
+```
+
+#### Output
+```
+Entering new AgentExecutor chain...
+ Yes.
+Follow up: Who is the reigning men's U.S. Open champion?
+Intermediate answer: Current champions Carlos Alcaraz, 2022 men's singles champion.
+Follow up: Where is Carlos Alcaraz from?
+Intermediate answer: El Palmar, Spain
+So the final answer is: El Palmar, Spain
+
+> Finished chain.
+
+'El Palmar, Spain'
+```
+
+For a more detailed walkthrough of this wrapper, see [this notebook](/docs/integrations/tools/google_serper).
+
+### Tool
+
+You can also easily load this wrapper as a Tool (to use with an Agent).
+You can do this with:
+```python
+from langchain.agents import load_tools
+tools = load_tools(["google-serper"])
+```
+
+For more information on tools, see [this page](/docs/how_to/tools_builtin).

langchain_md_files/integrations/providers/gooseai.mdx

@@ -0,0 +1,23 @@
+# GooseAI
+
+This page covers how to use the GooseAI ecosystem within LangChain.
+It is broken into two parts: installation and setup, and then references to specific GooseAI wrappers.
+
+## Installation and Setup
+- Install the Python SDK with `pip install openai`
+- Get your GooseAI api key from this link [here](https://goose.ai/).
+- Set the environment variable (`GOOSEAI_API_KEY`).
+
+```python
+import os
+os.environ["GOOSEAI_API_KEY"] = "YOUR_API_KEY"
+```
+
+## Wrappers
+
+### LLM
+
+There exists an GooseAI LLM wrapper, which you can access with: 
+```python
+from langchain_community.llms import GooseAI
+```

langchain_md_files/integrations/providers/gpt4all.mdx

@@ -0,0 +1,55 @@
+# GPT4All
+
+This page covers how to use the `GPT4All` wrapper within LangChain. The tutorial is divided into two parts: installation and setup, followed by usage with an example.
+
+## Installation and Setup
+
+- Install the Python package with `pip install gpt4all`
+- Download a [GPT4All model](https://gpt4all.io/index.html) and place it in your desired directory
+
+In this example, we are using `mistral-7b-openorca.Q4_0.gguf`:
+
+```bash
+mkdir models
+wget https://gpt4all.io/models/gguf/mistral-7b-openorca.Q4_0.gguf -O models/mistral-7b-openorca.Q4_0.gguf
+```
+
+## Usage
+
+### GPT4All
+
+To use the GPT4All wrapper, you need to provide the path to the pre-trained model file and the model's configuration.
+
+```python
+from langchain_community.llms import GPT4All
+
+# Instantiate the model. Callbacks support token-wise streaming
+model = GPT4All(model="./models/mistral-7b-openorca.Q4_0.gguf", n_threads=8)
+
+# Generate text
+response = model.invoke("Once upon a time, ")
+```
+
+You can also customize the generation parameters, such as `n_predict`, `temp`, `top_p`, `top_k`, and others.
+
+To stream the model's predictions, add in a CallbackManager.
+
+```python
+from langchain_community.llms import GPT4All
+from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
+
+# There are many CallbackHandlers supported, such as
+# from langchain.callbacks.streamlit import StreamlitCallbackHandler
+
+callbacks = [StreamingStdOutCallbackHandler()]
+model = GPT4All(model="./models/mistral-7b-openorca.Q4_0.gguf", n_threads=8)
+
+# Generate text. Tokens are streamed through the callback manager.
+model.invoke("Once upon a time, ", callbacks=callbacks)
+```
+
+## Model File
+
+You can download model files from the GPT4All client. You can download the client from the [GPT4All](https://gpt4all.io/index.html) website.
+
+For a more detailed walkthrough of this, see [this notebook](/docs/integrations/llms/gpt4all)

langchain_md_files/integrations/providers/gradient.mdx

@@ -0,0 +1,27 @@
+# Gradient
+
+>[Gradient](https://gradient.ai/) allows to fine tune and get completions on LLMs with a simple web API.
+
+## Installation and Setup
+- Install the Python SDK :
+```bash
+pip install gradientai
+```
+Get a [Gradient access token and workspace](https://gradient.ai/) and set it as an environment variable (`Gradient_ACCESS_TOKEN`) and (`GRADIENT_WORKSPACE_ID`)
+
+## LLM
+
+There exists an Gradient LLM wrapper, which you can access with 
+See a [usage example](/docs/integrations/llms/gradient).
+
+```python
+from langchain_community.llms import GradientLLM
+```
+
+## Text Embedding Model
+
+There exists an Gradient Embedding model, which you can access with 
+```python
+from langchain_community.embeddings import GradientEmbeddings
+```
+For a more detailed walkthrough of this, see [this notebook](/docs/integrations/text_embedding/gradient)

langchain_md_files/integrations/providers/graphsignal.mdx

@@ -0,0 +1,44 @@
+# Graphsignal
+
+This page covers how to use [Graphsignal](https://app.graphsignal.com) to trace and monitor LangChain. Graphsignal enables full visibility into your application. It provides latency breakdowns by chains and tools, exceptions with full context, data monitoring, compute/GPU utilization, OpenAI cost analytics, and more.
+
+## Installation and Setup
+
+- Install the Python library with `pip install graphsignal`
+- Create free Graphsignal account [here](https://graphsignal.com)
+- Get an API key and set it as an environment variable (`GRAPHSIGNAL_API_KEY`)
+
+## Tracing and Monitoring
+
+Graphsignal automatically instruments and starts tracing and monitoring chains. Traces and metrics are then available in your [Graphsignal dashboards](https://app.graphsignal.com).
+
+Initialize the tracer by providing a deployment name:
+
+```python
+import graphsignal
+
+graphsignal.configure(deployment='my-langchain-app-prod')
+```
+
+To additionally trace any function or code, you can use a decorator or a context manager:
+
+```python
+@graphsignal.trace_function
+def handle_request():    
+    chain.run("some initial text")
+```
+
+```python
+with graphsignal.start_trace('my-chain'):
+    chain.run("some initial text")
+```
+
+Optionally, enable profiling to record function-level statistics for each trace.
+
+```python
+with graphsignal.start_trace(
+        'my-chain', options=graphsignal.TraceOptions(enable_profiling=True)):
+    chain.run("some initial text")
+```
+
+See the [Quick Start](https://graphsignal.com/docs/guides/quick-start/) guide for complete setup instructions.

langchain_md_files/integrations/providers/grobid.mdx

@@ -0,0 +1,46 @@
+# Grobid
+
+GROBID is a machine learning library for extracting, parsing, and re-structuring raw documents.
+
+It is designed and expected to be used to parse academic papers, where it works particularly well.
+
+*Note*: if the articles supplied to Grobid are large documents (e.g. dissertations) exceeding a certain number
+of elements, they might not be processed.
+
+This page covers how to use the Grobid to parse articles for LangChain.
+
+## Installation
+The grobid installation is described in details in https://grobid.readthedocs.io/en/latest/Install-Grobid/.
+However, it is probably easier and less troublesome to run grobid through a docker container,
+as documented [here](https://grobid.readthedocs.io/en/latest/Grobid-docker/).
+
+## Use Grobid with LangChain
+
+Once grobid is installed and up and running (you can check by accessing it http://localhost:8070),
+you're ready to go.
+
+You can now use the GrobidParser to produce documents
+```python
+from langchain_community.document_loaders.parsers import GrobidParser
+from langchain_community.document_loaders.generic import GenericLoader
+
+#Produce chunks from article paragraphs
+loader = GenericLoader.from_filesystem(
+    "/Users/31treehaus/Desktop/Papers/",
+    glob="*",
+    suffixes=[".pdf"],
+    parser= GrobidParser(segment_sentences=False)
+)
+docs = loader.load()
+
+#Produce chunks from article sentences
+loader = GenericLoader.from_filesystem(
+    "/Users/31treehaus/Desktop/Papers/",
+    glob="*",
+    suffixes=[".pdf"],
+    parser= GrobidParser(segment_sentences=True)
+)
+docs = loader.load()
+```
+Chunk metadata will include Bounding Boxes. Although these are a bit funky to parse,
+they are explained in https://grobid.readthedocs.io/en/latest/Coordinates-in-PDF/

langchain_md_files/integrations/providers/groq.mdx

@@ -0,0 +1,28 @@
+# Groq
+
+Welcome to Groq! 🚀 At Groq, we've developed the world's first Language Processing Unit™, or LPU. The Groq LPU has a deterministic, single core streaming architecture that sets the standard for GenAI inference speed with predictable and repeatable performance for any given workload.
+
+Beyond the architecture, our software is designed to empower developers like you with the tools you need to create innovative, powerful AI applications. With Groq as your engine, you can:
+
+* Achieve uncompromised low latency and performance for real-time AI and HPC inferences 🔥
+* Know the exact performance and compute time for any given workload 🔮
+* Take advantage of our cutting-edge technology to stay ahead of the competition 💪
+
+Want more Groq? Check out our [website](https://groq.com) for more resources and join our [Discord community](https://discord.gg/JvNsBDKeCG) to connect with our developers!
+
+
+## Installation and Setup
+Install the integration package:
+
+```bash
+pip install langchain-groq
+```
+
+Request an [API key](https://wow.groq.com) and set it as an environment variable:
+
+```bash
+export GROQ_API_KEY=gsk_...
+```
+
+## Chat Model
+See a [usage example](/docs/integrations/chat/groq).

langchain_md_files/integrations/providers/gutenberg.mdx

@@ -0,0 +1,15 @@
+# Gutenberg
+
+>[Project Gutenberg](https://www.gutenberg.org/about/) is an online library of free eBooks.
+
+## Installation and Setup
+
+There isn't any special setup for it.
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/gutenberg).
+
+```python
+from langchain_community.document_loaders import GutenbergLoader
+```

langchain_md_files/integrations/providers/hacker_news.mdx

@@ -0,0 +1,18 @@
+# Hacker News
+
+>[Hacker News](https://en.wikipedia.org/wiki/Hacker_News) (sometimes abbreviated as `HN`) is a social news 
+> website focusing on computer science and entrepreneurship. It is run by the investment fund and startup 
+> incubator `Y Combinator`. In general, content that can be submitted is defined as "anything that gratifies 
+> one's intellectual curiosity."
+
+## Installation and Setup
+
+There isn't any special setup for it.
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/hacker_news).
+
+```python
+from langchain_community.document_loaders import HNLoader
+```

langchain_md_files/integrations/providers/hazy_research.mdx

@@ -0,0 +1,19 @@
+# Hazy Research
+
+This page covers how to use the Hazy Research ecosystem within LangChain.
+It is broken into two parts: installation and setup, and then references to specific Hazy Research wrappers.
+
+## Installation and Setup
+- To use the `manifest`, install it with `pip install manifest-ml`
+
+## Wrappers
+
+### LLM
+
+There exists an LLM wrapper around Hazy Research's `manifest` library. 
+`manifest` is a python library which is itself a wrapper around many model providers, and adds in caching, history, and more.
+
+To use this wrapper:
+```python
+from langchain_community.llms.manifest import ManifestWrapper
+```

langchain_md_files/integrations/providers/helicone.mdx

@@ -0,0 +1,53 @@
+# Helicone
+
+This page covers how to use the [Helicone](https://helicone.ai) ecosystem within LangChain.
+
+## What is Helicone?
+
+Helicone is an [open-source](https://github.com/Helicone/helicone) observability platform that proxies your OpenAI traffic and provides you key insights into your spend, latency and usage.
+
+![Screenshot of the Helicone dashboard showing average requests per day, response time, tokens per response, total cost, and a graph of requests over time.](/img/HeliconeDashboard.png "Helicone Dashboard")
+
+## Quick start
+
+With your LangChain environment you can just add the following parameter.
+
+```bash
+export OPENAI_API_BASE="https://oai.hconeai.com/v1"
+```
+
+Now head over to [helicone.ai](https://www.helicone.ai/signup) to create your account, and add your OpenAI API key within our dashboard to view your logs.
+
+![Interface for entering and managing OpenAI API keys in the Helicone dashboard.](/img/HeliconeKeys.png "Helicone API Key Input")
+
+## How to enable Helicone caching
+
+```python
+from langchain_openai import OpenAI
+import openai
+openai.api_base = "https://oai.hconeai.com/v1"
+
+llm = OpenAI(temperature=0.9, headers={"Helicone-Cache-Enabled": "true"})
+text = "What is a helicone?"
+print(llm.invoke(text))
+```
+
+[Helicone caching docs](https://docs.helicone.ai/advanced-usage/caching)
+
+## How to use Helicone custom properties
+
+```python
+from langchain_openai import OpenAI
+import openai
+openai.api_base = "https://oai.hconeai.com/v1"
+
+llm = OpenAI(temperature=0.9, headers={
+        "Helicone-Property-Session": "24",
+        "Helicone-Property-Conversation": "support_issue_2",
+        "Helicone-Property-App": "mobile",
+      })
+text = "What is a helicone?"
+print(llm.invoke(text))
+```
+
+[Helicone property docs](https://docs.helicone.ai/advanced-usage/custom-properties)

langchain_md_files/integrations/providers/hologres.mdx

@@ -0,0 +1,23 @@
+# Hologres
+
+>[Hologres](https://www.alibabacloud.com/help/en/hologres/latest/introduction) is a unified real-time data warehousing service developed by Alibaba Cloud. You can use Hologres to write, update, process, and analyze large amounts of data in real time. 
+>`Hologres` supports standard `SQL` syntax, is compatible with `PostgreSQL`, and supports most PostgreSQL functions. Hologres supports online analytical processing (OLAP) and ad hoc analysis for up to petabytes of data, and provides high-concurrency and low-latency online data services. 
+
+>`Hologres` provides **vector database** functionality by adopting [Proxima](https://www.alibabacloud.com/help/en/hologres/latest/vector-processing).
+>`Proxima` is a high-performance software library developed by `Alibaba DAMO Academy`. It allows you to search for the nearest neighbors of vectors. Proxima provides higher stability and performance than similar open-source software such as Faiss. Proxima allows you to search for similar text or image embeddings with high throughput and low latency. Hologres is deeply integrated with Proxima to provide a high-performance vector search service.
+
+## Installation and Setup
+
+Click [here](https://www.alibabacloud.com/zh/product/hologres) to fast deploy a Hologres cloud instance.
+
+```bash
+pip install hologres-vector
+```
+
+## Vector Store
+
+See a [usage example](/docs/integrations/vectorstores/hologres).
+
+```python
+from langchain_community.vectorstores import Hologres
+```

langchain_md_files/integrations/providers/html2text.mdx

@@ -0,0 +1,19 @@
+# HTML to text
+
+>[html2text](https://github.com/Alir3z4/html2text/) is a Python package that converts a page of `HTML` into clean, easy-to-read plain `ASCII text`. 
+
+The ASCII also happens to be a valid `Markdown` (a text-to-HTML format).
+
+## Installation and Setup
+
+```bash
+pip install html2text
+```
+
+## Document Transformer
+
+See a [usage example](/docs/integrations/document_transformers/html2text).
+
+```python
+from langchain_community.document_loaders import Html2TextTransformer
+```

langchain_md_files/integrations/providers/huawei.mdx

@@ -0,0 +1,37 @@
+# Huawei
+
+>[Huawei Technologies Co., Ltd.](https://www.huawei.com/) is a Chinese multinational 
+> digital communications technology corporation.
+> 
+>[Huawei Cloud](https://www.huaweicloud.com/intl/en-us/product/) provides a comprehensive suite of 
+> global cloud computing services. 
+ 
+
+## Installation and Setup
+
+To access the `Huawei Cloud`, you need an access token.
+
+You also have to install a python library:
+
+```bash
+pip install -U esdk-obs-python
+```
+
+
+## Document Loader
+
+### Huawei OBS Directory
+
+See a [usage example](/docs/integrations/document_loaders/huawei_obs_directory).
+
+```python
+from langchain_community.document_loaders import OBSDirectoryLoader
+```
+
+### Huawei OBS File
+
+See a [usage example](/docs/integrations/document_loaders/huawei_obs_file).
+
+```python
+from langchain_community.document_loaders.obs_file import OBSFileLoader
+```

langchain_md_files/integrations/providers/ibm.mdx

@@ -0,0 +1,59 @@
+# IBM
+
+The `LangChain` integrations related to [IBM watsonx.ai](https://www.ibm.com/products/watsonx-ai) platform.
+
+IBM® watsonx.ai™ AI studio is part of the IBM [watsonx](https://www.ibm.com/watsonx)™ AI and data platform, bringing together new generative 
+AI capabilities powered by [foundation models](https://www.ibm.com/products/watsonx-ai/foundation-models) and traditional machine learning (ML) 
+into a powerful studio spanning the AI lifecycle. Tune and guide models with your enterprise data to meet your needs with easy-to-use tools for 
+building and refining performant prompts. With watsonx.ai, you can build AI applications in a fraction of the time and with a fraction of the data. 
+Watsonx.ai offers:
+
+- **Multi-model variety and flexibility:** Choose from IBM-developed, open-source and third-party models, or build your own model.
+- **Differentiated client protection:** IBM stands behind IBM-developed models and indemnifies the client against third-party IP claims.
+- **End-to-end AI governance:** Enterprises can scale and accelerate the impact of AI with trusted data across the business, using data wherever it resides.
+- **Hybrid, multi-cloud deployments:** IBM provides the flexibility to integrate and deploy your AI workloads into your hybrid-cloud stack of choice.
+
+
+## Installation and Setup
+
+Install the integration package with
+```bash
+pip install -qU langchain-ibm
+```
+
+Get an IBM watsonx.ai api key and set it as an environment variable (`WATSONX_APIKEY`)
+```python
+import os
+
+os.environ["WATSONX_APIKEY"] = "your IBM watsonx.ai api key"
+```
+
+## Chat Model
+
+### ChatWatsonx
+
+See a [usage example](/docs/integrations/chat/ibm_watsonx).
+
+```python
+from langchain_ibm import ChatWatsonx
+```
+
+## LLMs
+
+### WatsonxLLM
+
+See a [usage example](/docs/integrations/llms/ibm_watsonx).
+
+```python
+from langchain_ibm import WatsonxLLM
+```
+
+## Embedding Models
+
+### WatsonxEmbeddings
+
+See a [usage example](/docs/integrations/text_embedding/ibm_watsonx).
+
+```python
+from langchain_ibm import WatsonxEmbeddings
+```

langchain_md_files/integrations/providers/ieit_systems.mdx

@@ -0,0 +1,31 @@
+# IEIT Systems
+
+>[IEIT Systems](https://en.ieisystem.com/) is a Chinese information technology company 
+> established in 1999. It provides the IT infrastructure products, solutions, 
+> and services, innovative IT products and solutions across cloud computing, 
+> big data, and artificial intelligence.
+
+
+## LLMs
+
+See a [usage example](/docs/integrations/llms/yuan2).
+
+```python
+from langchain_community.llms.yuan2 import Yuan2
+```
+
+## Chat models
+
+See the [installation instructions](/docs/integrations/chat/yuan2/#setting-up-your-api-server).
+
+Yuan2.0 provided an OpenAI compatible API, and ChatYuan2 is integrated into langchain by using `OpenAI client`. 
+Therefore, ensure the `openai` package is installed.
+
+```bash
+pip install openai
+```
+See a [usage example](/docs/integrations/chat/yuan2).
+
+```python
+from langchain_community.chat_models import ChatYuan2
+```

langchain_md_files/integrations/providers/ifixit.mdx

@@ -0,0 +1,16 @@
+# iFixit
+
+>[iFixit](https://www.ifixit.com) is the largest, open repair community on the web. The site contains nearly 100k 
+> repair manuals, 200k Questions & Answers on 42k devices, and all the data is licensed under `CC-BY-NC-SA 3.0`.
+
+## Installation and Setup
+
+There isn't any special setup for it.
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/ifixit).
+
+```python
+from langchain_community.document_loaders import IFixitLoader
+```

langchain_md_files/integrations/providers/iflytek.mdx

@@ -0,0 +1,38 @@
+# iFlytek
+
+>[iFlytek](https://www.iflytek.com) is a Chinese information technology company 
+> established in 1999. It creates voice recognition software and 
+> voice-based internet/mobile products covering education, communication, 
+> music, intelligent toys industries.
+
+
+## Installation and Setup
+
+- Get `SparkLLM` app_id, api_key and api_secret from [iFlyTek SparkLLM API Console](https://console.xfyun.cn/services/bm3) (for more info, see [iFlyTek SparkLLM Intro](https://xinghuo.xfyun.cn/sparkapi)).
+- Install the Python package (not for the embedding models):
+
+```bash
+pip install websocket-client
+```
+
+## LLMs
+
+See a [usage example](/docs/integrations/llms/sparkllm).
+
+```python
+from langchain_community.llms import SparkLLM
+```
+
+## Chat models
+
+See a [usage example](/docs/integrations/chat/sparkllm).
+
+```python
+from langchain_community.chat_models import ChatSparkLLM
+```
+
+## Embedding models
+
+```python
+from langchain_community.embeddings import SparkLLMTextEmbeddings
+```

langchain_md_files/integrations/providers/imsdb.mdx

@@ -0,0 +1,16 @@
+# IMSDb
+
+>[IMSDb](https://imsdb.com/) is the `Internet Movie Script Database`.
+> 
+## Installation and Setup
+
+There isn't any special setup for it.
+
+## Document Loader
+
+See a [usage example](/docs/integrations/document_loaders/imsdb).
+
+
+```python
+from langchain_community.document_loaders import IMSDbLoader
+```

langchain_md_files/integrations/providers/infinispanvs.mdx

@@ -0,0 +1,17 @@
+# Infinispan VS
+
+> [Infinispan](https://infinispan.org) Infinispan is an open-source in-memory data grid that provides
+> a key/value data store able to hold all types of data, from Java objects to plain text.
+> Since version 15 Infinispan supports vector search over caches.
+
+## Installation and Setup
+See [Get Started](https://infinispan.org/get-started/) to run an Infinispan server, you may want to disable authentication
+(not supported atm)
+
+## Vector Store
+
+See a [usage example](/docs/integrations/vectorstores/infinispanvs).
+
+```python
+from langchain_community.vectorstores import InfinispanVS
+```

langchain_md_files/integrations/providers/infinity.mdx

@@ -0,0 +1,11 @@
+# Infinity
+
+>[Infinity](https://github.com/michaelfeil/infinity) allows the creation of text embeddings.
+
+## Text Embedding Model
+
+There exists an infinity Embedding model, which you can access with 
+```python
+from langchain_community.embeddings import InfinityEmbeddings
+```
+For a more detailed walkthrough of this, see [this notebook](/docs/integrations/text_embedding/infinity)

langchain_md_files/integrations/providers/infino.mdx

@@ -0,0 +1,35 @@
+# Infino
+
+>[Infino](https://github.com/infinohq/infino) is an open-source observability platform that stores both metrics and application logs together.
+
+Key features of `Infino` include:
+- **Metrics Tracking**: Capture time taken by LLM model to handle request, errors, number of tokens, and costing indication for the particular LLM.
+- **Data Tracking**: Log and store prompt, request, and response data for each LangChain interaction.
+- **Graph Visualization**: Generate basic graphs over time, depicting metrics such as request duration, error occurrences, token count, and cost.
+
+## Installation and Setup
+
+First, you'll need to install the  `infinopy` Python package as follows:
+
+```bash
+pip install infinopy
+```
+
+If you already have an `Infino Server` running, then you're good to go; but if
+you don't, follow the next steps to start it:
+
+- Make sure you have Docker installed
+- Run the following in your terminal:
+    ```
+    docker run --rm --detach --name infino-example -p 3000:3000 infinohq/infino:latest
+    ```
+
+
+
+## Using Infino
+
+See a [usage example of `InfinoCallbackHandler`](/docs/integrations/callbacks/infino).
+
+```python
+from langchain.callbacks import InfinoCallbackHandler
+```

langchain_md_files/integrations/providers/intel.mdx

@@ -0,0 +1,108 @@
+# Intel
+
+>[Optimum Intel](https://github.com/huggingface/optimum-intel?tab=readme-ov-file#optimum-intel) is the interface between the 🤗 Transformers and Diffusers libraries and the different tools and libraries provided by Intel to accelerate end-to-end pipelines on Intel architectures.
+
+>[Intel® Extension for Transformers](https://github.com/intel/intel-extension-for-transformers?tab=readme-ov-file#intel-extension-for-transformers) (ITREX) is an innovative toolkit designed to accelerate GenAI/LLM everywhere with the optimal performance of Transformer-based models on various Intel platforms, including Intel Gaudi2, Intel CPU, and Intel GPU.
+
+This page covers how to use optimum-intel and ITREX with LangChain.
+
+## Optimum-intel
+
+All functionality related to the [optimum-intel](https://github.com/huggingface/optimum-intel.git) and [IPEX](https://github.com/intel/intel-extension-for-pytorch).
+
+### Installation
+
+Install using optimum-intel and ipex using:
+
+```bash
+pip install optimum[neural-compressor]
+pip install intel_extension_for_pytorch
+```
+
+Please follow the installation instructions as specified below:
+
+* Install optimum-intel as shown [here](https://github.com/huggingface/optimum-intel).
+* Install IPEX as shown [here](https://intel.github.io/intel-extension-for-pytorch/index.html#installation?platform=cpu&version=v2.2.0%2Bcpu).
+
+### Embedding Models
+
+See a [usage example](/docs/integrations/text_embedding/optimum_intel).
+We also offer a full tutorial notebook "rag_with_quantized_embeddings.ipynb" for using the embedder in a RAG pipeline in the cookbook dir.
+
+```python
+from langchain_community.embeddings import QuantizedBiEncoderEmbeddings
+```
+
+## Intel® Extension for Transformers (ITREX)
+(ITREX) is an innovative toolkit to accelerate Transformer-based models on Intel platforms, in particular, effective on 4th Intel Xeon Scalable processor Sapphire Rapids (codenamed Sapphire Rapids).
+
+Quantization is a process that involves reducing the precision of these weights by representing them using a smaller number of bits. Weight-only quantization specifically focuses on quantizing the weights of the neural network while keeping other components, such as activations, in their original precision.
+
+As large language models (LLMs) become more prevalent, there is a growing need for new and improved quantization methods that can meet the computational demands of these modern architectures while maintaining the accuracy. Compared to [normal quantization](https://github.com/intel/intel-extension-for-transformers/blob/main/docs/quantization.md) like W8A8, weight only quantization is probably a better trade-off to balance the performance and the accuracy, since we will see below that the bottleneck of deploying LLMs is the memory bandwidth and normally weight only quantization could lead to better accuracy.
+
+Here, we will introduce Embedding Models and Weight-only quantization for Transformers large language models with ITREX. Weight-only quantization is a technique used in deep learning to reduce the memory and computational requirements of neural networks. In the context of deep neural networks, the model parameters, also known as weights, are typically represented using floating-point numbers, which can consume a significant amount of memory and require intensive computational resources.
+
+All functionality related to the [intel-extension-for-transformers](https://github.com/intel/intel-extension-for-transformers).
+
+### Installation
+
+Install intel-extension-for-transformers. For system requirements and other installation tips, please refer to [Installation Guide](https://github.com/intel/intel-extension-for-transformers/blob/main/docs/installation.md)
+
+```bash
+pip install intel-extension-for-transformers
+```
+Install other required packages.
+
+```bash
+pip install -U torch onnx accelerate datasets
+```
+
+### Embedding Models
+
+See a [usage example](/docs/integrations/text_embedding/itrex).
+
+```python
+from langchain_community.embeddings import QuantizedBgeEmbeddings
+```
+
+### Weight-Only Quantization with ITREX
+
+See a [usage example](/docs/integrations/llms/weight_only_quantization).
+
+## Detail of Configuration Parameters
+
+Here is the detail of the `WeightOnlyQuantConfig` class.
+
+#### weight_dtype (string): Weight Data Type, default is "nf4".
+We support quantize the weights to following data types for storing(weight_dtype in WeightOnlyQuantConfig):
+* **int8**: Uses 8-bit data type.
+* **int4_fullrange**: Uses the -8 value of int4 range compared with the normal int4 range [-7,7].
+* **int4_clip**: Clips and retains the values within the int4 range, setting others to zero.
+* **nf4**: Uses the normalized float 4-bit data type.
+* **fp4_e2m1**: Uses regular float 4-bit data type. "e2" means that 2 bits are used for the exponent, and "m1" means that 1 bits are used for the mantissa.
+
+#### compute_dtype (string): Computing Data Type, Default is "fp32".
+While these techniques store weights in 4 or 8 bit, the computation still happens in float32, bfloat16 or int8(compute_dtype in WeightOnlyQuantConfig):
+* **fp32**: Uses the float32 data type to compute.
+* **bf16**: Uses the bfloat16 data type to compute.
+* **int8**: Uses 8-bit data type to compute.
+
+#### llm_int8_skip_modules (list of module's name): Modules to Skip Quantization, Default is None.
+It is a list of modules to be skipped quantization.
+
+#### scale_dtype (string): The Scale Data Type, Default is "fp32".
+Now only support "fp32"(float32).
+
+#### mse_range (boolean): Whether to Search for The Best Clip Range from Range [0.805, 1.0, 0.005], default is False.
+#### use_double_quant (boolean): Whether to Quantize Scale, Default is False.
+Not support yet.
+#### double_quant_dtype (string): Reserve for Double Quantization.
+#### double_quant_scale_dtype (string): Reserve for Double Quantization.
+#### group_size (int): Group Size When Auantization.
+#### scheme (string): Which Format Weight Be Quantize to. Default is "sym".
+* **sym**: Symmetric.
+* **asym**: Asymmetric.
+#### algorithm (string): Which Algorithm to Improve the Accuracy . Default is "RTN"
+* **RTN**: Round-to-nearest (RTN) is a quantification method that we can think of very intuitively.
+* **AWQ**: Protecting only 1% of salient weights can greatly reduce quantization error. the salient weight channels are selected by observing the distribution of activation and weight per channel. The salient weights are also quantized after multiplying a big scale factor before quantization for preserving. .
+* **TEQ**: A trainable equivalent transformation that preserves the FP32 precision in weight-only quantization.