8c9be11e3bec88c20cee865fdfde76c9db80fb3f7c6408cf9569e19be7a869e7

langchain_md_files/integrations/providers/iugu.mdx

@@ -1,19 +0,0 @@
-# Iugu
-
->[Iugu](https://www.iugu.com/) is a Brazilian services and software as a service (SaaS)
-> company. It offers payment-processing software and application programming 
-> interfaces for e-commerce websites and mobile applications.
- 
-
-## Installation and Setup
-
-The `Iugu API` requires an access token, which can be found inside of the `Iugu` dashboard.
-
-
-## Document Loader
-
-See a [usage example](/docs/integrations/document_loaders/iugu).
-
-```python
-from langchain_community.document_loaders import IuguLoader
-```

langchain_md_files/integrations/providers/jaguar.mdx

@@ -1,62 +0,0 @@
-# Jaguar
-
-This page describes how to use Jaguar vector database within LangChain.
-It contains three sections: introduction, installation and setup, and Jaguar API.
-
-
-## Introduction
-
-Jaguar vector database has the following characteristics:
-
-1. It is a distributed vector database
-2. The “ZeroMove” feature of JaguarDB enables instant horizontal scalability
-3. Multimodal: embeddings, text, images, videos, PDFs, audio, time series, and geospatial
-4. All-masters: allows both parallel reads and writes
-5. Anomaly detection capabilities
-6. RAG support: combines LLM with proprietary and real-time data
-7. Shared metadata: sharing of metadata across multiple vector indexes
-8. Distance metrics: Euclidean, Cosine, InnerProduct, Manhatten, Chebyshev, Hamming, Jeccard, Minkowski
-
-[Overview of Jaguar scalable vector database](http://www.jaguardb.com)
-
-You can run JaguarDB in docker container; or download the software and run on-cloud or off-cloud.
-
-## Installation and Setup
-
-- Install the JaguarDB on one host or multiple hosts
-- Install the Jaguar HTTP Gateway server on one host
-- Install the JaguarDB HTTP Client package
-
-The steps are described in [Jaguar Documents](http://www.jaguardb.com/support.html)
-
-Environment Variables in client programs:
-
-    export OPENAI_API_KEY="......"
-    export JAGUAR_API_KEY="......"
-
-  
-## Jaguar API
-
-Together with LangChain, a Jaguar client class is provided by importing it in Python:
-
-```python
-from langchain_community.vectorstores.jaguar import Jaguar
-```
-
-Supported API functions of the Jaguar class are:
-
-- `add_texts`
-- `add_documents`
-- `from_texts`
-- `from_documents`
-- `similarity_search`
-- `is_anomalous`
-- `create`
-- `delete`
-- `clear`
-- `drop`
-- `login`
-- `logout`
-
-
-For more details of the Jaguar API, please refer to [this notebook](/docs/integrations/vectorstores/jaguar)

langchain_md_files/integrations/providers/javelin_ai_gateway.mdx

@@ -1,92 +0,0 @@
-# Javelin AI Gateway
-
-[The Javelin AI Gateway](https://www.getjavelin.io) service is a high-performance, enterprise grade API Gateway for AI applications.  
-It is designed to streamline the usage and access of various large language model (LLM) providers, 
-such as OpenAI, Cohere, Anthropic and custom large language models within an organization by incorporating
-robust access security for all interactions with LLMs. 
-
-Javelin offers a high-level interface that simplifies the interaction with LLMs by providing a unified endpoint 
-to handle specific LLM related requests. 
-
-See the Javelin AI Gateway [documentation](https://docs.getjavelin.io) for more details.  
-[Javelin Python SDK](https://www.github.com/getjavelin/javelin-python) is an easy to use client library meant to be embedded into AI Applications
-
-## Installation and Setup
-
-Install `javelin_sdk` to interact with Javelin AI Gateway:
-
-```sh
-pip install 'javelin_sdk'
-```
-
-Set the Javelin's API key as an environment variable:
-
-```sh
-export JAVELIN_API_KEY=...
-```
-
-## Completions Example
-
-```python
-
-from langchain.chains import LLMChain
-from langchain_community.llms import JavelinAIGateway
-from langchain_core.prompts import PromptTemplate
-
-route_completions = "eng_dept03"
-
-gateway = JavelinAIGateway(
-    gateway_uri="http://localhost:8000",
-    route=route_completions,
-    model_name="text-davinci-003",
-)
-
-llmchain = LLMChain(llm=gateway, prompt=prompt)
-result = llmchain.run("podcast player")
-
-print(result)
-
-```
-
-## Embeddings Example
-
-```python
-from langchain_community.embeddings import JavelinAIGatewayEmbeddings
-from langchain_openai import OpenAIEmbeddings
-
-embeddings = JavelinAIGatewayEmbeddings(
-    gateway_uri="http://localhost:8000",
-    route="embeddings",
-)
-
-print(embeddings.embed_query("hello"))
-print(embeddings.embed_documents(["hello"]))
-```
-
-## Chat Example
-```python
-from langchain_community.chat_models import ChatJavelinAIGateway
-from langchain_core.messages import HumanMessage, SystemMessage
-
-messages = [
-    SystemMessage(
-        content="You are a helpful assistant that translates English to French."
-    ),
-    HumanMessage(
-        content="Artificial Intelligence has the power to transform humanity and make the world a better place"
-    ),
-]
-
-chat = ChatJavelinAIGateway(
-    gateway_uri="http://localhost:8000",
-    route="mychatbot_route",
-    model_name="gpt-3.5-turbo"
-    params={
-        "temperature": 0.1
-    }
-)
-
-print(chat(messages))
-
-```
-

langchain_md_files/integrations/providers/jina.mdx

@@ -1,20 +0,0 @@
-# Jina
-
-This page covers how to use the Jina Embeddings within LangChain.
-It is broken into two parts: installation and setup, and then references to specific Jina wrappers.
-
-## Installation and Setup
-- Get a Jina AI API token from [here](https://jina.ai/embeddings/) and set it as an environment variable (`JINA_API_TOKEN`)
-
-There exists a Jina Embeddings wrapper, which you can access with 
-
-```python
-from langchain_community.embeddings import JinaEmbeddings
-
-# you can pas jina_api_key, if none is passed it will be taken from `JINA_API_TOKEN` environment variable
-embeddings = JinaEmbeddings(jina_api_key='jina_**', model_name='jina-embeddings-v2-base-en')
-```
-
-You can check the list of available models from [here](https://jina.ai/embeddings/)
-
-For a more detailed walkthrough of this, see [this notebook](/docs/integrations/text_embedding/jina)

langchain_md_files/integrations/providers/johnsnowlabs.mdx

@@ -1,117 +0,0 @@
-# Johnsnowlabs
-
-Gain access to the [johnsnowlabs](https://www.johnsnowlabs.com/) ecosystem of enterprise NLP libraries
-with over 21.000 enterprise NLP models in over 200 languages with the open source `johnsnowlabs` library.
-For all 24.000+ models, see the [John Snow Labs Model Models Hub](https://nlp.johnsnowlabs.com/models)
-
-## Installation and Setup
-
-
-```bash
-pip install johnsnowlabs
-```
-
-To [install enterprise features](https://nlp.johnsnowlabs.com/docs/en/jsl/install_licensed_quick, run:
-```python
-# for more details see https://nlp.johnsnowlabs.com/docs/en/jsl/install_licensed_quick
-nlp.install()
-```
-
-
-You can embed your queries and documents with either `gpu`,`cpu`,`apple_silicon`,`aarch` based optimized binaries.
-By default cpu binaries are used.
-Once a session is started, you must restart your notebook to switch between GPU or CPU, or changes will not take effect.
-
-## Embed Query with CPU:
-```python
-document = "foo bar"
-embedding = JohnSnowLabsEmbeddings('embed_sentence.bert')
-output = embedding.embed_query(document)
-```
-
-
-## Embed Query with GPU:
-
-
-```python
-document = "foo bar"
-embedding = JohnSnowLabsEmbeddings('embed_sentence.bert','gpu')
-output = embedding.embed_query(document)
-```
-
-
-
-
-## Embed Query with Apple Silicon (M1,M2,etc..):
-
-```python
-documents = ["foo bar", 'bar foo']
-embedding = JohnSnowLabsEmbeddings('embed_sentence.bert','apple_silicon')
-output = embedding.embed_query(document)
-```
-
-
-
-## Embed Query with AARCH:
-
-```python
-documents = ["foo bar", 'bar foo']
-embedding = JohnSnowLabsEmbeddings('embed_sentence.bert','aarch')
-output = embedding.embed_query(document)
-```
-
-
-
-
-
-
-## Embed Document with CPU:
-```python
-documents = ["foo bar", 'bar foo']
-embedding = JohnSnowLabsEmbeddings('embed_sentence.bert','gpu')
-output = embedding.embed_documents(documents)
-```
-
-
-
-## Embed Document with GPU:
-
-```python
-documents = ["foo bar", 'bar foo']
-embedding = JohnSnowLabsEmbeddings('embed_sentence.bert','gpu')
-output = embedding.embed_documents(documents)
-```
-
-
-
-
-
-## Embed Document with Apple Silicon (M1,M2,etc..):
-
-```python
-
-```python
-documents = ["foo bar", 'bar foo']
-embedding = JohnSnowLabsEmbeddings('embed_sentence.bert','apple_silicon')
-output = embedding.embed_documents(documents)
-```
-
-
-
-## Embed Document with AARCH:
-
-```python
-
-```python
-documents = ["foo bar", 'bar foo']
-embedding = JohnSnowLabsEmbeddings('embed_sentence.bert','aarch')
-output = embedding.embed_documents(documents)
-```
-
-
-
-
-Models are loaded with [nlp.load](https://nlp.johnsnowlabs.com/docs/en/jsl/load_api) and spark session is started with [nlp.start()](https://nlp.johnsnowlabs.com/docs/en/jsl/start-a-sparksession) under the hood.
-
-
-

langchain_md_files/integrations/providers/joplin.mdx

@@ -1,19 +0,0 @@
-# Joplin
-
->[Joplin](https://joplinapp.org/) is an open-source note-taking app. It captures your thoughts 
-> and securely accesses them from any device.
- 
-
-## Installation and Setup
-
-The `Joplin API` requires an access token. 
-You can find installation instructions [here](https://joplinapp.org/api/references/rest_api/).
-
-
-## Document Loader
-
-See a [usage example](/docs/integrations/document_loaders/joplin).
-
-```python
-from langchain_community.document_loaders import JoplinLoader
-```

langchain_md_files/integrations/providers/kdbai.mdx

@@ -1,24 +0,0 @@
-# KDB.AI
-
->[KDB.AI](https://kdb.ai) is a powerful knowledge-based vector database and search engine that allows you to build scalable, reliable AI applications, using real-time data, by providing advanced search, recommendation and personalization.
-
-
-## Installation and Setup
-
-Install the Python SDK:
-
-```bash
-pip install kdbai-client
-```
-
-
-## Vector store
-
-There exists a wrapper around KDB.AI indexes, allowing you to use it as a vectorstore,
-whether for semantic search or example selection.
-
-```python
-from langchain_community.vectorstores import KDBAI
-```
-
-For a more detailed walkthrough of the KDB.AI vectorstore, see [this notebook](/docs/integrations/vectorstores/kdbai)

langchain_md_files/integrations/providers/kinetica.mdx

@@ -1,44 +0,0 @@
-# Kinetica
-
-[Kinetica](https://www.kinetica.com/) is a real-time database purpose built for enabling
-analytics and generative AI on time-series & spatial data.
-
-## Chat Model
-
-The Kinetica LLM wrapper uses the [Kinetica SqlAssist
-LLM](https://docs.kinetica.com/7.2/sql-gpt/concepts/) to transform natural language into
-SQL to simplify the process of data retrieval.
-
-See [Kinetica Language To SQL Chat Model](/docs/integrations/chat/kinetica) for usage.
-
-```python
-from langchain_community.chat_models.kinetica import ChatKinetica
-```
-
-## Vector Store
-
-The Kinetca vectorstore wrapper leverages Kinetica's native support for [vector
-similarity search](https://docs.kinetica.com/7.2/vector_search/).
-
-See [Kinetica Vectorsore API](/docs/integrations/vectorstores/kinetica) for usage.
-
-```python
-from langchain_community.vectorstores import Kinetica
-```
-
-## Document Loader
-
-The Kinetica Document loader can be used to load LangChain Documents from the
-Kinetica database.
-
-See [Kinetica Document Loader](/docs/integrations/document_loaders/kinetica) for usage
-
-```python
-from langchain_community.document_loaders.kinetica_loader import KineticaLoader
-```
-
-## Retriever
-
-The Kinetica Retriever can return documents given an unstructured query.
-
-See [Kinetica VectorStore based Retriever](/docs/integrations/retrievers/kinetica) for usage

langchain_md_files/integrations/providers/konko.mdx

@@ -1,65 +0,0 @@
-# Konko
-All functionality related to Konko
-
->[Konko AI](https://www.konko.ai/) provides a fully managed API to help application developers
-
->1. **Select** the right open source or proprietary LLMs for their application
->2. **Build** applications faster with integrations to leading application frameworks and fully managed APIs
->3. **Fine tune** smaller open-source LLMs to achieve industry-leading performance at a fraction of the cost
->4. **Deploy production-scale APIs** that meet security, privacy, throughput, and latency SLAs without infrastructure set-up or administration using Konko AI's SOC 2 compliant, multi-cloud infrastructure
-
-## Installation and Setup
-
-1. Sign in to our web app to [create an API key](https://platform.konko.ai/settings/api-keys) to access models via our endpoints for [chat completions](https://docs.konko.ai/reference/post-chat-completions) and [completions](https://docs.konko.ai/reference/post-completions).
-2. Enable a Python3.8+ environment
-3. Install the SDK
-
-```bash
-pip install konko
-```
-
-4. Set API Keys as environment variables(`KONKO_API_KEY`,`OPENAI_API_KEY`)
-
-```bash
-export KONKO_API_KEY={your_KONKO_API_KEY_here}
-export OPENAI_API_KEY={your_OPENAI_API_KEY_here} #Optional
-```
-
-Please see [the Konko docs](https://docs.konko.ai/docs/getting-started) for more details.
-
-
-## LLM
-
-**Explore Available Models:** Start by browsing through the [available models](https://docs.konko.ai/docs/list-of-models) on Konko. Each model caters to different use cases and capabilities.
-
-Another way to find the list of models running on the Konko instance is through this [endpoint](https://docs.konko.ai/reference/get-models).
-
-See a usage [example](/docs/integrations/llms/konko).
-
-### Examples of Endpoint Usage
-
-- **Completion with mistralai/Mistral-7B-v0.1:**
-
-  ```python
-  from langchain_community.llms import Konko
-  llm = Konko(max_tokens=800, model='mistralai/Mistral-7B-v0.1')
-  prompt = "Generate a Product Description for Apple Iphone 15"
-  response = llm.invoke(prompt)
-  ```
-
-## Chat Models
-
-See a usage [example](/docs/integrations/chat/konko).
-
-
-- **ChatCompletion with Mistral-7B:**
-
-  ```python
-  from langchain_core.messages import HumanMessage
-  from langchain_community.chat_models import ChatKonko
-  chat_instance = ChatKonko(max_tokens=10, model = 'mistralai/mistral-7b-instruct-v0.1')
-  msg = HumanMessage(content="Hi")
-  chat_response = chat_instance([msg])
-  ```
-
-For further assistance, contact [[email protected]](mailto:[email protected]) or join our [Discord](https://discord.gg/TXV2s3z7RZ).

langchain_md_files/integrations/providers/labelstudio.mdx

@@ -1,23 +0,0 @@
-# Label Studio
-
-
->[Label Studio](https://labelstud.io/guide/get_started) is an open-source data labeling platform that provides LangChain with flexibility when it comes to labeling data for fine-tuning large language models (LLMs). It also enables the preparation of custom training data and the collection and evaluation of responses through human feedback.
-
-## Installation and Setup
-
-See the [Label Studio installation guide](https://labelstud.io/guide/install) for installation options.
-
-We need to install the  `label-studio` and `label-studio-sdk-python` Python packages:
-
-```bash
-pip install label-studio label-studio-sdk
-```
-
-
-## Callbacks
-
-See a [usage example](/docs/integrations/callbacks/labelstudio).
-
-```python
-from langchain.callbacks import LabelStudioCallbackHandler
-```

langchain_md_files/integrations/providers/lakefs.mdx

@@ -1,18 +0,0 @@
-# lakeFS
-
->[lakeFS](https://docs.lakefs.io/) provides scalable version control over 
-> the data lake, and uses Git-like semantics to create and access those versions. 
-
-## Installation and Setup
-
-Get the `ENDPOINT`, `LAKEFS_ACCESS_KEY`, and `LAKEFS_SECRET_KEY`.
-You can find installation instructions [here](https://docs.lakefs.io/quickstart/launch.html).
-
-
-## Document Loader
-
-See a [usage example](/docs/integrations/document_loaders/lakefs).
-
-```python
-from langchain_community.document_loaders import LakeFSLoader
-```

langchain_md_files/integrations/providers/lancedb.mdx

@@ -1,23 +0,0 @@
-# LanceDB
-
-This page covers how to use [LanceDB](https://github.com/lancedb/lancedb) within LangChain.
-It is broken into two parts: installation and setup, and then references to specific LanceDB wrappers.
-
-## Installation and Setup
-
-- Install the Python SDK with `pip install lancedb`
-
-## Wrappers
-
-### VectorStore
-
-There exists a wrapper around LanceDB 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 LanceDB
-```
-
-For a more detailed walkthrough of the LanceDB wrapper, see [this notebook](/docs/integrations/vectorstores/lancedb)

langchain_md_files/integrations/providers/langchain_decorators.mdx

@@ -1,370 +0,0 @@
-# LangChain Decorators ✨
-
-~~~
-Disclaimer: `LangChain decorators` is not created by the LangChain team and is not supported by it.
-~~~
-
->`LangChain decorators` is a layer on the top of LangChain that provides syntactic sugar 🍭 for writing custom langchain prompts and chains
->
->For Feedback, Issues, Contributions - please raise an issue here: 
->[ju-bezdek/langchain-decorators](https://github.com/ju-bezdek/langchain-decorators)
-
-
-Main principles and benefits:
-
-- more `pythonic` way of writing code
-- write multiline prompts that won't break your code flow with indentation
-- making use of IDE in-built support for **hinting**, **type checking** and **popup with docs** to quickly peek in the function to see the prompt, parameters it consumes etc.
-- leverage all the power of 🦜🔗 LangChain ecosystem
-- adding support for **optional parameters**
-- easily share parameters between the prompts by binding them to one class
-
-
-Here is a simple example of a code written with **LangChain Decorators ✨**
-
-``` python
-
-@llm_prompt
-def write_me_short_post(topic:str, platform:str="twitter", audience:str = "developers")->str:
-    """
-    Write me a short header for my post about {topic} for {platform} platform. 
-    It should be for {audience} audience.
-    (Max 15 words)
-    """
-    return
-
-# run it naturally
-write_me_short_post(topic="starwars")
-# or
-write_me_short_post(topic="starwars", platform="redit")
-```
-
-# Quick start
-## Installation
-```bash
-pip install langchain_decorators
-```
-
-## Examples
-
-Good idea on how to start is to review the examples here:
- - [jupyter notebook](https://github.com/ju-bezdek/langchain-decorators/blob/main/example_notebook.ipynb)
- - [colab notebook](https://colab.research.google.com/drive/1no-8WfeP6JaLD9yUtkPgym6x0G9ZYZOG#scrollTo=N4cf__D0E2Yk)
-
-# Defining other parameters
-Here we are just marking a function as a prompt with `llm_prompt` decorator, turning it effectively into a LLMChain. Instead of running it 
-
-
-Standard LLMchain takes much more init parameter than just inputs_variables and prompt... here is this implementation detail hidden in the decorator.
-Here is how it works:
-
-1. Using **Global settings**:
-
-``` python
-# define global settings for all prompty (if not set - chatGPT is the current default)
-from langchain_decorators import GlobalSettings
-
-GlobalSettings.define_settings(
-    default_llm=ChatOpenAI(temperature=0.0), this is default... can change it here globally
-    default_streaming_llm=ChatOpenAI(temperature=0.0,streaming=True), this is default... can change it here for all ... will be used for streaming
-)
-```
-
-2. Using predefined **prompt types**
-
-``` python
-#You can change the default prompt types
-from langchain_decorators import PromptTypes, PromptTypeSettings
-
-PromptTypes.AGENT_REASONING.llm = ChatOpenAI()
-
-# Or you can just define your own ones:
-class MyCustomPromptTypes(PromptTypes):
-    GPT4=PromptTypeSettings(llm=ChatOpenAI(model="gpt-4"))
-
-@llm_prompt(prompt_type=MyCustomPromptTypes.GPT4) 
-def write_a_complicated_code(app_idea:str)->str:
-    ...
-
-```
-
-3.  Define the settings **directly in the decorator**
-
-``` python
-from langchain_openai import OpenAI
-
-@llm_prompt(
-    llm=OpenAI(temperature=0.7),
-    stop_tokens=["\nObservation"],
-    ...
-    )
-def creative_writer(book_title:str)->str:
-    ...
-```
-
-## Passing a memory and/or callbacks:
-
-To pass any of these, just declare them in the function (or use kwargs to pass anything)
-
-```python
-
-@llm_prompt()
-async def write_me_short_post(topic:str, platform:str="twitter", memory:SimpleMemory = None):
-    """
-    {history_key}
-    Write me a short header for my post about {topic} for {platform} platform. 
-    It should be for {audience} audience.
-    (Max 15 words)
-    """
-    pass
-
-await write_me_short_post(topic="old movies")
-
-```
-
-# Simplified streaming
-
-If we want to leverage streaming:
- - we need to define prompt as async function 
- - turn on the streaming on the decorator, or we can define PromptType with streaming on
- - capture the stream using StreamingContext
-
-This way we just mark which prompt should be streamed, not needing to tinker with what LLM should we use, passing around the creating and distribute streaming handler into particular part of our chain... just turn the streaming on/off on prompt/prompt type...
-
-The streaming will happen only if we call it in streaming context ... there we can define a simple function to handle the stream
-
-``` python
-# this code example is complete and should run as it is
-
-from langchain_decorators import StreamingContext, llm_prompt
-
-# this will mark the prompt for streaming (useful if we want stream just some prompts in our app... but don't want to pass distribute the callback handlers)
-# note that only async functions can be streamed (will get an error if it's not)
-@llm_prompt(capture_stream=True) 
-async def write_me_short_post(topic:str, platform:str="twitter", audience:str = "developers"):
-    """
-    Write me a short header for my post about {topic} for {platform} platform. 
-    It should be for {audience} audience.
-    (Max 15 words)
-    """
-    pass
-
-
-
-# just an arbitrary  function to demonstrate the streaming... will be some websockets code in the real world
-tokens=[]
-def capture_stream_func(new_token:str):
-    tokens.append(new_token)
-
-# if we want to capture the stream, we need to wrap the execution into StreamingContext... 
-# this will allow us to capture the stream even if the prompt call is hidden inside higher level method
-# only the prompts marked with capture_stream will be captured here
-with StreamingContext(stream_to_stdout=True, callback=capture_stream_func):
-    result = await run_prompt()
-    print("Stream finished ... we can distinguish tokens thanks to alternating colors")
-
-
-print("\nWe've captured",len(tokens),"tokens🎉\n")
-print("Here is the result:")
-print(result)
-```
-
-
-# Prompt declarations
-By default the prompt is is the whole function docs, unless you mark your prompt 
-
-## Documenting your prompt
-
-We can specify what part of our docs is the prompt definition, by specifying a code block with `<prompt>` language tag
-
-``` python
-@llm_prompt
-def write_me_short_post(topic:str, platform:str="twitter", audience:str = "developers"):
-    """
-    Here is a good way to write a prompt as part of a function docstring, with additional documentation for devs.
-
-    It needs to be a code block, marked as a `<prompt>` language
-    ```<prompt>
-    Write me a short header for my post about {topic} for {platform} platform. 
-    It should be for {audience} audience.
-    (Max 15 words)
-    ```
-
-    Now only to code block above will be used as a prompt, and the rest of the docstring will be used as a description for developers.
-    (It has also a nice benefit that IDE (like VS code) will display the prompt properly (not trying to parse it as markdown, and thus not showing new lines properly))
-    """
-    return 
-```
-
-## Chat messages prompt
-
-For chat models is very useful to define prompt as a set of message templates... here is how to do it:
-
-``` python
-@llm_prompt
-def simulate_conversation(human_input:str, agent_role:str="a pirate"):
-    """
-    ## System message
-     - note the `:system` suffix inside the <prompt:_role_> tag
-     
-
-    ```<prompt:system>
-    You are a {agent_role} hacker. You mus act like one.
-    You reply always in code, using python or javascript code block...
-    for example:
-    
-    ... do not reply with anything else.. just with code - respecting your role.
-    ```
-
-    # human message 
-    (we are using the real role that are enforced by the LLM - GPT supports system, assistant, user)
-    ``` <prompt:user>
-    Helo, who are you
-    ```
-    a reply:
-    
-
-    ``` <prompt:assistant>
-    \``` python <<- escaping inner code block with \ that should be part of the prompt
-    def hello():
-        print("Argh... hello you pesky pirate")
-    \```
-    ```
-    
-    we can also add some history using placeholder
-    ```<prompt:placeholder>
-    {history}
-    ```
-    ```<prompt:user>
-    {human_input}
-    ```
-
-    Now only to code block above will be used as a prompt, and the rest of the docstring will be used as a description for developers.
-    (It has also a nice benefit that IDE (like VS code) will display the prompt properly (not trying to parse it as markdown, and thus not showing new lines properly))
-    """
-    pass
-
-```
-
-the roles here are model native roles (assistant, user, system for chatGPT)
-
-
-
-# Optional sections
-- you can define a whole sections of your prompt that should be optional
-- if any input in the section is missing, the whole section won't be rendered
-
-the syntax for this is as follows:
-
-``` python
-@llm_prompt
-def prompt_with_optional_partials():
-    """
-    this text will be rendered always, but
-
-    {? anything inside this block will be rendered only if all the {value}s parameters are not empty (None | "")   ?}
-
-    you can also place it in between the words
-    this too will be rendered{? , but
-        this  block will be rendered only if {this_value} and {this_value}
-        is not empty?} !
-    """
-```
-
-
-# Output parsers
-
-- llm_prompt decorator natively tries to detect the best output parser based on the output type. (if not set, it returns the raw string)
-- list, dict and pydantic outputs are also supported natively (automatically)
-
-``` python
-# this code example is complete and should run as it is
-
-from langchain_decorators import llm_prompt
-
-@llm_prompt
-def write_name_suggestions(company_business:str, count:int)->list:
-    """ Write me {count} good name suggestions for company that {company_business}
-    """
-    pass
-
-write_name_suggestions(company_business="sells cookies", count=5)
-```
-
-## More complex structures
-
-for dict / pydantic you need to specify the formatting instructions... 
-this can be tedious, that's why you can let the output parser gegnerate you the instructions based on the model (pydantic)
-
-``` python
-from langchain_decorators import llm_prompt
-from pydantic import BaseModel, Field
-
-
-class TheOutputStructureWeExpect(BaseModel):
-    name:str = Field (description="The name of the company")
-    headline:str = Field( description="The description of the company (for landing page)")
-    employees:list[str] = Field(description="5-8 fake employee names with their positions")
-
-@llm_prompt()
-def fake_company_generator(company_business:str)->TheOutputStructureWeExpect:
-    """ Generate a fake company that {company_business}
-    {FORMAT_INSTRUCTIONS}
-    """
-    return
-
-company = fake_company_generator(company_business="sells cookies")
-
-# print the result nicely formatted
-print("Company name: ",company.name)
-print("company headline: ",company.headline)
-print("company employees: ",company.employees)
-
-```
-
-
-# Binding the prompt to an object
-
-``` python
-from pydantic import BaseModel
-from langchain_decorators import llm_prompt
-
-class AssistantPersonality(BaseModel):
-    assistant_name:str
-    assistant_role:str
-    field:str
-
-    @property
-    def a_property(self):
-        return "whatever"
-
-    def hello_world(self, function_kwarg:str=None):
-        """
-        We can reference any {field} or {a_property} inside our prompt... and combine it with {function_kwarg} in the method
-        """
-
-    
-    @llm_prompt
-    def introduce_your_self(self)->str:
-        """
-        ``` <prompt:system>
-        You are an assistant named {assistant_name}. 
-        Your role is to act as {assistant_role}
-        ```
-        ```<prompt:user>
-        Introduce your self (in less than 20 words)
-        ```
-        """
-
-    
-
-personality = AssistantPersonality(assistant_name="John", assistant_role="a pirate")
-
-print(personality.introduce_your_self(personality))
-```
-
-
-# More examples:
-
-- these and few more examples are also available in the [colab notebook here](https://colab.research.google.com/drive/1no-8WfeP6JaLD9yUtkPgym6x0G9ZYZOG#scrollTo=N4cf__D0E2Yk)
-- including the [ReAct Agent re-implementation](https://colab.research.google.com/drive/1no-8WfeP6JaLD9yUtkPgym6x0G9ZYZOG#scrollTo=3bID5fryE2Yp) using purely langchain decorators

langchain_md_files/integrations/providers/lantern.mdx

@@ -1,25 +0,0 @@
-# Lantern
-
-This page covers how to use the [Lantern](https://github.com/lanterndata/lantern) within LangChain
-It is broken into two parts: setup, and then references to specific Lantern wrappers.
-
-## Setup
-1. The first step is to create a database with the `lantern` extension installed.
-
-    Follow the steps at [Lantern Installation Guide](https://github.com/lanterndata/lantern#-quick-install) to install the database and the extension. The docker image is the easiest way to get started.
-
-## Wrappers
-
-### VectorStore
-
-There exists a wrapper around Postgres 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 Lantern
-```
-
-### Usage
-
-For a more detailed walkthrough of the Lantern Wrapper, see [this notebook](/docs/integrations/vectorstores/lantern)

langchain_md_files/integrations/providers/llamacpp.mdx

@@ -1,50 +0,0 @@
-# Llama.cpp
-
->[llama.cpp python](https://github.com/abetlen/llama-cpp-python) library is a simple Python bindings for `@ggerganov`
->[llama.cpp](https://github.com/ggerganov/llama.cpp).
->
->This package provides:
->
-> - Low-level access to C API via ctypes interface.
-> - High-level Python API for text completion
->   - `OpenAI`-like API
->   - `LangChain` compatibility
->   - `LlamaIndex` compatibility
-> - OpenAI compatible web server
->   - Local Copilot replacement
->   - Function Calling support
->   - Vision API support
->   - Multiple Models
-
-## Installation and Setup
-
-- Install the Python package
-  ```bash
-  pip install llama-cpp-python
-  ````
-- Download one of the [supported models](https://github.com/ggerganov/llama.cpp#description) and convert them to the llama.cpp format per the [instructions](https://github.com/ggerganov/llama.cpp)
-
-
-## Chat models
-
-See a [usage example](/docs/integrations/chat/llamacpp).
-
-```python
-from langchain_community.chat_models import ChatLlamaCpp
-```
-
-## LLMs
-
-See a [usage example](/docs/integrations/llms/llamacpp).
-
-```python
-from langchain_community.llms import LlamaCpp
-```
-
-## Embedding models
-
-See a [usage example](/docs/integrations/text_embedding/llamacpp).
-
-```python
-from langchain_community.embeddings import LlamaCppEmbeddings
-```

langchain_md_files/integrations/providers/llmonitor.mdx

@@ -1,22 +0,0 @@
-# LLMonitor
-
->[LLMonitor](https://llmonitor.com?utm_source=langchain&utm_medium=py&utm_campaign=docs) is an open-source observability platform that provides cost and usage analytics, user tracking, tracing and evaluation tools.
-
-## Installation and Setup
-
-Create an account on [llmonitor.com](https://llmonitor.com?utm_source=langchain&utm_medium=py&utm_campaign=docs), then copy your new app's `tracking id`.
-
-Once you have it, set it as an environment variable by running:
-
-```bash
-export LLMONITOR_APP_ID="..."
-```
-
-
-## Callbacks
-
-See a [usage example](/docs/integrations/callbacks/llmonitor).
-
-```python
-from langchain.callbacks import LLMonitorCallbackHandler
-```

langchain_md_files/integrations/providers/log10.mdx

@@ -1,104 +0,0 @@
-# Log10
-
-This page covers how to use the [Log10](https://log10.io) within LangChain.
-
-## What is Log10?
-
-Log10 is an [open-source](https://github.com/log10-io/log10) proxiless LLM data management and application development platform that lets you log, debug and tag your Langchain calls.
-
-## Quick start
-
-1. Create your free account at [log10.io](https://log10.io)
-2. Add your `LOG10_TOKEN` and `LOG10_ORG_ID` from the Settings and Organization tabs respectively as environment variables.
-3. Also add `LOG10_URL=https://log10.io` and your usual LLM API key: for e.g. `OPENAI_API_KEY` or `ANTHROPIC_API_KEY` to your environment
-
-## How to enable Log10 data management for Langchain
-
-Integration with log10 is a simple one-line `log10_callback` integration as shown below:
-
-```python
-from langchain_openai import ChatOpenAI
-from langchain_core.messages import HumanMessage
-
-from log10.langchain import Log10Callback
-from log10.llm import Log10Config
-
-log10_callback = Log10Callback(log10_config=Log10Config())
-
-messages = [
-    HumanMessage(content="You are a ping pong machine"),
-    HumanMessage(content="Ping?"),
-]
-
-llm = ChatOpenAI(model="gpt-3.5-turbo", callbacks=[log10_callback])
-```
-
-[Log10 + Langchain + Logs docs](https://github.com/log10-io/log10/blob/main/logging.md#langchain-logger)
-
-[More details + screenshots](https://log10.io/docs/observability/logs) including instructions for self-hosting logs
-
-## How to use tags with Log10
-
-```python
-from langchain_openai import OpenAI
-from langchain_community.chat_models import ChatAnthropic
-from langchain_openai import ChatOpenAI
-from langchain_core.messages import HumanMessage
-
-from log10.langchain import Log10Callback
-from log10.llm import Log10Config
-
-log10_callback = Log10Callback(log10_config=Log10Config())
-
-messages = [
-    HumanMessage(content="You are a ping pong machine"),
-    HumanMessage(content="Ping?"),
-]
-
-llm = ChatOpenAI(model="gpt-3.5-turbo", callbacks=[log10_callback], temperature=0.5, tags=["test"])
-completion = llm.predict_messages(messages, tags=["foobar"])
-print(completion)
-
-llm = ChatAnthropic(model="claude-2", callbacks=[log10_callback], temperature=0.7, tags=["baz"])
-llm.predict_messages(messages)
-print(completion)
-
-llm = OpenAI(model_name="gpt-3.5-turbo-instruct", callbacks=[log10_callback], temperature=0.5)
-completion = llm.predict("You are a ping pong machine.\nPing?\n")
-print(completion)
-```
-
-You can also intermix direct OpenAI calls and Langchain LLM calls:
-
-```python
-import os
-from log10.load import log10, log10_session
-import openai
-from langchain_openai import OpenAI
-
-log10(openai)
-
-with log10_session(tags=["foo", "bar"]):
-    # Log a direct OpenAI call
-    response = openai.Completion.create(
-        model="text-ada-001",
-        prompt="Where is the Eiffel Tower?",
-        temperature=0,
-        max_tokens=1024,
-        top_p=1,
-        frequency_penalty=0,
-        presence_penalty=0,
-    )
-    print(response)
-
-    # Log a call via Langchain
-    llm = OpenAI(model_name="text-ada-001", temperature=0.5)
-    response = llm.predict("You are a ping pong machine.\nPing?\n")
-    print(response)
-```
-
-## How to debug Langchain calls
-
-[Example of debugging](https://log10.io/docs/observability/prompt_chain_debugging)
-
-[More Langchain examples](https://github.com/log10-io/log10/tree/main/examples#langchain)

langchain_md_files/integrations/providers/maritalk.mdx

@@ -1,21 +0,0 @@
-# MariTalk
-
->[MariTalk](https://www.maritaca.ai/en) is an LLM-based chatbot trained to meet the needs of Brazil.
-
-## Installation and Setup
-
-You have to get the MariTalk API key.
-
-You also need to install the `httpx` Python package.
-
-```bash
-pip install httpx
-```
-
-## Chat models
-
-See a [usage example](/docs/integrations/chat/maritalk).
-
-```python
-from langchain_community.chat_models import ChatMaritalk
-```

langchain_md_files/integrations/providers/mediawikidump.mdx

@@ -1,31 +0,0 @@
-# MediaWikiDump
-
->[MediaWiki XML Dumps](https://www.mediawiki.org/wiki/Manual:Importing_XML_dumps) contain the content of a wiki 
-> (wiki pages with all their revisions), without the site-related data. A XML dump does not create a full backup 
-> of the wiki database, the dump does not contain user accounts, images, edit logs, etc.
-
-
-## Installation and Setup
-
-We need to install several python packages.
-
-The `mediawiki-utilities` supports XML schema 0.11 in unmerged branches.
-```bash
-pip install -qU git+https://github.com/mediawiki-utilities/python-mwtypes@updates_schema_0.11
-```
-
-The `mediawiki-utilities mwxml` has a bug, fix PR pending.
-
-```bash
-pip install -qU git+https://github.com/gdedrouas/python-mwxml@xml_format_0.11
-pip install -qU mwparserfromhell
-```
-
-## Document Loader
-
-See a [usage example](/docs/integrations/document_loaders/mediawikidump).
-
-
-```python
-from langchain_community.document_loaders import MWDumpLoader
-```

langchain_md_files/integrations/providers/meilisearch.mdx

@@ -1,30 +0,0 @@
-# Meilisearch
-
-> [Meilisearch](https://meilisearch.com) is an open-source, lightning-fast, and hyper
-> relevant search engine. 
-> It comes with great defaults to help developers build snappy search experiences. 
->
-> You can [self-host Meilisearch](https://www.meilisearch.com/docs/learn/getting_started/installation#local-installation) 
-> or run on [Meilisearch Cloud](https://www.meilisearch.com/pricing).
->
->`Meilisearch v1.3` supports vector search.
-
-## Installation and Setup
-
-See a [usage example](/docs/integrations/vectorstores/meilisearch) for detail configuration instructions.
-
-
-We need to install `meilisearch` python package.
-
-```bash
-pip install meilisearch
-```
-
-## Vector Store
-
-See a [usage example](/docs/integrations/vectorstores/meilisearch).
-
-```python
-from langchain_community.vectorstores import Meilisearch
-```
-

langchain_md_files/integrations/providers/metal.mdx

@@ -1,26 +0,0 @@
-# Metal
-
-This page covers how to use [Metal](https://getmetal.io) within LangChain.
-
-## What is Metal?
-
-Metal is a  managed retrieval & memory platform built for production. Easily index your data into `Metal` and run semantic search and retrieval on it.
-
-![Screenshot of the Metal dashboard showing the Browse Index feature with sample data.](/img/MetalDash.png "Metal Dashboard Interface")
-
-## Quick start
-
-Get started by [creating a Metal account](https://app.getmetal.io/signup).
-
-Then, you can easily take advantage of the `MetalRetriever` class to start retrieving your data for semantic search, prompting context, etc. This class takes a `Metal` instance and a dictionary of parameters to pass to the Metal API.
-
-```python
-from langchain.retrievers import MetalRetriever
-from metal_sdk.metal import Metal
-
-
-metal = Metal("API_KEY", "CLIENT_ID", "INDEX_ID");
-retriever = MetalRetriever(metal, params={"limit": 2})
-
-docs = retriever.invoke("search term")
-```

langchain_md_files/integrations/providers/milvus.mdx

@@ -1,25 +0,0 @@
-# Milvus
-
->[Milvus](https://milvus.io/docs/overview.md) is a database that stores, indexes, and manages
-> massive embedding vectors generated by deep neural networks and other machine learning (ML) models.
-
-
-## Installation and Setup
-
-Install the Python SDK:
-
-```bash
-pip install pymilvus
-```
-
-## Vector Store
-
-There exists a wrapper around `Milvus` 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 Milvus
-```
-
-For a more detailed walkthrough of the `Miluvs` wrapper, see [this notebook](/docs/integrations/vectorstores/milvus)

langchain_md_files/integrations/providers/mindsdb.mdx

@@ -1,14 +0,0 @@
-# MindsDB
-
-MindsDB is the platform for customizing AI from enterprise data. With MindsDB and it's nearly 200 integrations to [data sources](https://docs.mindsdb.com/integrations/data-overview) and [AI/ML frameworks](https://docs.mindsdb.com/integrations/ai-overview), any developer can use their enterprise data to customize AI for their purpose, faster and more securely.
-
-With MindsDB, you can connect any data source to any AI/ML model to implement and automate AI-powered applications. Deploy, serve, and fine-tune models in real-time, utilizing data from databases, vector stores, or applications. Do all that using universal tools developers already know.
-
-MindsDB integrates with LangChain, enabling users to:
-
-
-- Deploy models available via LangChain within MindsDB, making them accessible to numerous data sources.
-- Fine-tune models available via LangChain within MindsDB using real-time and dynamic data.
-- Automate AI workflows with LangChain and MindsDB.
-
-Follow [our docs](https://docs.mindsdb.com/integrations/ai-engines/langchain) to learn more about MindsDB’s integration with LangChain and see examples.

langchain_md_files/integrations/providers/minimax.mdx

@@ -1,33 +0,0 @@
-# Minimax
-
->[Minimax](https://api.minimax.chat) is a Chinese startup that provides natural language processing models
-> for companies and individuals.
-
-## Installation and Setup
-Get a [Minimax api key](https://api.minimax.chat/user-center/basic-information/interface-key) and set it as an environment variable (`MINIMAX_API_KEY`)
-Get a [Minimax group id](https://api.minimax.chat/user-center/basic-information) and set it as an environment variable (`MINIMAX_GROUP_ID`)
-
-
-## LLM
-
-There exists a Minimax LLM wrapper, which you can access with
-See a [usage example](/docs/integrations/llms/minimax).
-
-```python
-from langchain_community.llms import Minimax
-```
-
-## Chat Models
-
-See a [usage example](/docs/integrations/chat/minimax)
-
-```python
-from langchain_community.chat_models import MiniMaxChat
-```
-
-## Text Embedding Model
-
-There exists a Minimax Embedding model, which you can access with
-```python
-from langchain_community.embeddings import MiniMaxEmbeddings
-```

langchain_md_files/integrations/providers/mistralai.mdx

@@ -1,34 +0,0 @@
-# MistralAI
-
->[Mistral AI](https://docs.mistral.ai/api/) is a platform that offers hosting for their powerful open source models.
-
-
-## Installation and Setup
-
-A valid [API key](https://console.mistral.ai/users/api-keys/) is needed to communicate with the API.
-
-You will also need the `langchain-mistralai` package:
-
-```bash
-pip install langchain-mistralai
-```
-
-## Chat models
-
-### ChatMistralAI
-
-See a [usage example](/docs/integrations/chat/mistralai).
-
-```python
-from langchain_mistralai.chat_models import ChatMistralAI
-```
-
-## Embedding models
-
-### MistralAIEmbeddings
-
-See a [usage example](/docs/integrations/text_embedding/mistralai).
-
-```python
-from langchain_mistralai import MistralAIEmbeddings
-```

langchain_md_files/integrations/providers/mlflow.mdx

@@ -1,119 +0,0 @@
-# MLflow Deployments for LLMs
-
->[The MLflow Deployments for LLMs](https://www.mlflow.org/docs/latest/llms/deployments/index.html) is a powerful tool designed to streamline the usage and management of various large
-> language model (LLM) providers, such as OpenAI and Anthropic, within an organization. It offers a high-level interface
-> that simplifies the interaction with these services by providing a unified endpoint to handle specific LLM related requests.
-
-## Installation and Setup
-
-Install `mlflow` with MLflow Deployments dependencies:
-
-```sh
-pip install 'mlflow[genai]'
-```
-
-Set the OpenAI API key as an environment variable:
-
-```sh
-export OPENAI_API_KEY=...
-```
-
-Create a configuration file:
-
-```yaml
-endpoints:
-  - name: completions
-    endpoint_type: llm/v1/completions
-    model:
-      provider: openai
-      name: text-davinci-003
-      config:
-        openai_api_key: $OPENAI_API_KEY
-
-  - name: embeddings
-    endpoint_type: llm/v1/embeddings
-    model:
-      provider: openai
-      name: text-embedding-ada-002
-      config:
-        openai_api_key: $OPENAI_API_KEY
-```
-
-Start the deployments server:
-
-```sh
-mlflow deployments start-server --config-path /path/to/config.yaml
-```
-
-## Example provided by `MLflow`
-
->The `mlflow.langchain` module provides an API for logging and loading `LangChain` models.
-> This module exports multivariate LangChain models in the langchain flavor and univariate LangChain
-> models in the pyfunc flavor.
-
-See the [API documentation and examples](https://www.mlflow.org/docs/latest/llms/langchain/index.html) for more information.
-
-## Completions Example
-
-```python
-import mlflow
-from langchain.chains import LLMChain, PromptTemplate
-from langchain_community.llms import Mlflow
-
-llm = Mlflow(
-    target_uri="http://127.0.0.1:5000",
-    endpoint="completions",
-)
-
-llm_chain = LLMChain(
-    llm=Mlflow,
-    prompt=PromptTemplate(
-        input_variables=["adjective"],
-        template="Tell me a {adjective} joke",
-    ),
-)
-result = llm_chain.run(adjective="funny")
-print(result)
-
-with mlflow.start_run():
-    model_info = mlflow.langchain.log_model(chain, "model")
-
-model = mlflow.pyfunc.load_model(model_info.model_uri)
-print(model.predict([{"adjective": "funny"}]))
-```
-
-## Embeddings Example
-
-```python
-from langchain_community.embeddings import MlflowEmbeddings
-
-embeddings = MlflowEmbeddings(
-    target_uri="http://127.0.0.1:5000",
-    endpoint="embeddings",
-)
-
-print(embeddings.embed_query("hello"))
-print(embeddings.embed_documents(["hello"]))
-```
-
-## Chat Example
-
-```python
-from langchain_community.chat_models import ChatMlflow
-from langchain_core.messages import HumanMessage, SystemMessage
-
-chat = ChatMlflow(
-    target_uri="http://127.0.0.1:5000",
-    endpoint="chat",
-)
-
-messages = [
-    SystemMessage(
-        content="You are a helpful assistant that translates English to French."
-    ),
-    HumanMessage(
-        content="Translate this sentence from English to French: I love programming."
-    ),
-]
-print(chat(messages))
-```

langchain_md_files/integrations/providers/mlflow_ai_gateway.mdx

@@ -1,160 +0,0 @@
-# MLflow AI Gateway
-
-:::warning
-
-MLflow AI Gateway has been deprecated. Please use [MLflow Deployments for LLMs](/docs/integrations/providers/mlflow/) instead.
-
-:::
-
->[The MLflow AI Gateway](https://www.mlflow.org/docs/latest/index.html) service is a powerful tool designed to streamline the usage and management of various large 
-> language model (LLM) providers, such as OpenAI and Anthropic, within an organization. It offers a high-level interface 
-> that simplifies the interaction with these services by providing a unified endpoint to handle specific LLM related requests.
-
-## Installation and Setup
-
-Install `mlflow` with MLflow AI Gateway dependencies:
-
-```sh
-pip install 'mlflow[gateway]'
-```
-
-Set the OpenAI API key as an environment variable:
-
-```sh
-export OPENAI_API_KEY=...
-```
-
-Create a configuration file:
-
-```yaml
-routes:
-  - name: completions
-    route_type: llm/v1/completions
-    model:
-      provider: openai
-      name: text-davinci-003
-      config:
-        openai_api_key: $OPENAI_API_KEY
-
-  - name: embeddings
-    route_type: llm/v1/embeddings
-    model:
-      provider: openai
-      name: text-embedding-ada-002
-      config:
-        openai_api_key: $OPENAI_API_KEY
-```
-
-Start the Gateway server:
-
-```sh
-mlflow gateway start --config-path /path/to/config.yaml
-```
-
-## Example provided by `MLflow`
-
->The `mlflow.langchain` module provides an API for logging and loading `LangChain` models. 
-> This module exports multivariate LangChain models in the langchain flavor and univariate LangChain 
-> models in the pyfunc flavor.
- 
-See the [API documentation and examples](https://www.mlflow.org/docs/latest/python_api/mlflow.langchain.html?highlight=langchain#module-mlflow.langchain).
-
-
-
-## Completions Example
-
-```python
-import mlflow
-from langchain.chains import LLMChain, PromptTemplate
-from langchain_community.llms import MlflowAIGateway
-
-gateway = MlflowAIGateway(
-    gateway_uri="http://127.0.0.1:5000",
-    route="completions",
-    params={
-        "temperature": 0.0,
-        "top_p": 0.1,
-    },
-)
-
-llm_chain = LLMChain(
-    llm=gateway,
-    prompt=PromptTemplate(
-        input_variables=["adjective"],
-        template="Tell me a {adjective} joke",
-    ),
-)
-result = llm_chain.run(adjective="funny")
-print(result)
-
-with mlflow.start_run():
-    model_info = mlflow.langchain.log_model(chain, "model")
-
-model = mlflow.pyfunc.load_model(model_info.model_uri)
-print(model.predict([{"adjective": "funny"}]))
-```
-
-## Embeddings Example
-
-```python
-from langchain_community.embeddings import MlflowAIGatewayEmbeddings
-
-embeddings = MlflowAIGatewayEmbeddings(
-    gateway_uri="http://127.0.0.1:5000",
-    route="embeddings",
-)
-
-print(embeddings.embed_query("hello"))
-print(embeddings.embed_documents(["hello"]))
-```
-
-## Chat Example
-
-```python
-from langchain_community.chat_models import ChatMLflowAIGateway
-from langchain_core.messages import HumanMessage, SystemMessage
-
-chat = ChatMLflowAIGateway(
-    gateway_uri="http://127.0.0.1:5000",
-    route="chat",
-    params={
-        "temperature": 0.1
-    }
-)
-
-messages = [
-    SystemMessage(
-        content="You are a helpful assistant that translates English to French."
-    ),
-    HumanMessage(
-        content="Translate this sentence from English to French: I love programming."
-    ),
-]
-print(chat(messages))
-```
-
-## Databricks MLflow AI Gateway
-
-Databricks MLflow AI Gateway is in private preview.
-Please contact a Databricks representative to enroll in the preview.
-
-```python
-from langchain.chains import LLMChain
-from langchain_core.prompts import PromptTemplate
-from langchain_community.llms import MlflowAIGateway
-
-gateway = MlflowAIGateway(
-    gateway_uri="databricks",
-    route="completions",
-)
-
-llm_chain = LLMChain(
-    llm=gateway,
-    prompt=PromptTemplate(
-        input_variables=["adjective"],
-        template="Tell me a {adjective} joke",
-    ),
-)
-result = llm_chain.run(adjective="funny")
-print(result)
-```

langchain_md_files/integrations/providers/mlx.mdx

@@ -1,34 +0,0 @@
-# MLX
-
->[MLX](https://ml-explore.github.io/mlx/build/html/index.html) is a `NumPy`-like array framework 
-> designed for efficient and flexible machine learning on `Apple` silicon, 
-> brought to you by `Apple machine learning research`.
-
-
-## Installation and Setup
-
-Install several Python packages:
-
-```bash
-pip install mlx-lm transformers huggingface_hub
-````
-
-
-## Chat models
-
-
-See a [usage example](/docs/integrations/chat/mlx).
-
-```python
-from langchain_community.chat_models.mlx import ChatMLX
-```
-
-## LLMs
-
-### MLX Local Pipelines
-
-See a [usage example](/docs/integrations/llms/mlx_pipelines).
-
-```python
-from langchain_community.llms.mlx_pipeline import MLXPipeline
-```

langchain_md_files/integrations/providers/modal.mdx

@@ -1,95 +0,0 @@
-# Modal
-
-This page covers how to use the Modal ecosystem to run LangChain custom LLMs.
-It is broken into two parts: 
-
-1. Modal installation and web endpoint deployment
-2. Using deployed web endpoint with `LLM` wrapper class.
-
-## Installation and Setup
-
-- Install with `pip install modal`
-- Run `modal token new`
-
-## Define your Modal Functions and Webhooks
-
-You must include a prompt. There is a rigid response structure:
-
-```python
-class Item(BaseModel):
-    prompt: str
-
-@stub.function()
-@modal.web_endpoint(method="POST")
-def get_text(item: Item):
-    return {"prompt": run_gpt2.call(item.prompt)}
-```
-
-The following is an example with the GPT2 model:
-
-```python
-from pydantic import BaseModel
-
-import modal
-
-CACHE_PATH = "/root/model_cache"
-
-class Item(BaseModel):
-    prompt: str
-
-stub = modal.Stub(name="example-get-started-with-langchain")
-
-def download_model():
-    from transformers import GPT2Tokenizer, GPT2LMHeadModel
-    tokenizer = GPT2Tokenizer.from_pretrained('gpt2')
-    model = GPT2LMHeadModel.from_pretrained('gpt2')
-    tokenizer.save_pretrained(CACHE_PATH)
-    model.save_pretrained(CACHE_PATH)
-
-# Define a container image for the LLM function below, which
-# downloads and stores the GPT-2 model.
-image = modal.Image.debian_slim().pip_install(
-    "tokenizers", "transformers", "torch", "accelerate"
-).run_function(download_model)
-
-@stub.function(
-    gpu="any",
-    image=image,
-    retries=3,
-)
-def run_gpt2(text: str):
-    from transformers import GPT2Tokenizer, GPT2LMHeadModel
-    tokenizer = GPT2Tokenizer.from_pretrained(CACHE_PATH)
-    model = GPT2LMHeadModel.from_pretrained(CACHE_PATH)
-    encoded_input = tokenizer(text, return_tensors='pt').input_ids
-    output = model.generate(encoded_input, max_length=50, do_sample=True)
-    return tokenizer.decode(output[0], skip_special_tokens=True)
-
-@stub.function()
-@modal.web_endpoint(method="POST")
-def get_text(item: Item):
-    return {"prompt": run_gpt2.call(item.prompt)}
-```
-
-### Deploy the web endpoint
-
-Deploy the web endpoint to Modal cloud with the [`modal deploy`](https://modal.com/docs/reference/cli/deploy) CLI command.
-Your web endpoint will acquire a persistent URL under the `modal.run` domain.
-
-## LLM wrapper around Modal web endpoint
-
-The  `Modal` LLM wrapper class which will accept your deployed web endpoint's URL.
-
-```python
-from langchain_community.llms import Modal
-
-endpoint_url = "https://ecorp--custom-llm-endpoint.modal.run"  # REPLACE ME with your deployed Modal web endpoint's URL
-
-llm = Modal(endpoint_url=endpoint_url)
-llm_chain = LLMChain(prompt=prompt, llm=llm)
-
-question = "What NFL team won the Super Bowl in the year Justin Beiber was born?"
-
-llm_chain.run(question)
-```
-

langchain_md_files/integrations/providers/modelscope.mdx

@@ -1,24 +0,0 @@
-# ModelScope
-
->[ModelScope](https://www.modelscope.cn/home) is a big repository of the models and datasets.
-
-This page covers how to use the modelscope ecosystem within LangChain.
-It is broken into two parts: installation and setup, and then references to specific modelscope wrappers.
-
-## Installation and Setup
-
-Install the `modelscope` package.
- 
-```bash
-pip install modelscope
-```
-
-
-## Text Embedding Models
-
-
-```python
-from langchain_community.embeddings import ModelScopeEmbeddings
-```
-
-For a more detailed walkthrough of this, see [this notebook](/docs/integrations/text_embedding/modelscope_hub)

langchain_md_files/integrations/providers/modern_treasury.mdx

@@ -1,19 +0,0 @@
-# Modern Treasury
-
->[Modern Treasury](https://www.moderntreasury.com/) simplifies complex payment operations. It is a unified platform to power products and processes that move money.
->- Connect to banks and payment systems
->- Track transactions and balances in real-time
->- Automate payment operations for scale
-
-## Installation and Setup
-
-There isn't any special setup for it.
-
-## Document Loader
-
-See a [usage example](/docs/integrations/document_loaders/modern_treasury).
-
-
-```python
-from langchain_community.document_loaders import ModernTreasuryLoader
-```

langchain_md_files/integrations/providers/momento.mdx

@@ -1,65 +0,0 @@
-# Momento
-
-> [Momento Cache](https://docs.momentohq.com/) is the world's first truly serverless caching service, offering instant elasticity, scale-to-zero
-> capability, and blazing-fast performance.
->
-> [Momento Vector Index](https://docs.momentohq.com/vector-index) stands out as the most productive, easiest-to-use, fully serverless vector index.
->
-> For both services, simply grab the SDK, obtain an API key, input a few lines into your code, and you're set to go. Together, they provide a comprehensive solution for your LLM data needs.
-
-This page covers how to use the [Momento](https://gomomento.com) ecosystem within LangChain.
-
-## Installation and Setup
-
-- Sign up for a free account [here](https://console.gomomento.com/) to get an API key
-- Install the Momento Python SDK with `pip install momento`
-
-## Cache
-
-Use Momento as a serverless, distributed, low-latency cache for LLM prompts and responses. The standard cache is the primary use case for Momento users in any environment.
-
-To integrate Momento Cache into your application:
-
-```python
-from langchain.cache import MomentoCache
-```
-
-Then, set it up with the following code:
-
-```python
-from datetime import timedelta
-from momento import CacheClient, Configurations, CredentialProvider
-from langchain.globals import set_llm_cache
-
-# Instantiate the Momento client
-cache_client = CacheClient(
-    Configurations.Laptop.v1(),
-    CredentialProvider.from_environment_variable("MOMENTO_API_KEY"),
-    default_ttl=timedelta(days=1))
-
-# Choose a Momento cache name of your choice
-cache_name = "langchain"
-
-# Instantiate the LLM cache
-set_llm_cache(MomentoCache(cache_client, cache_name))
-```
-
-## Memory
-
-Momento can be used as a distributed memory store for LLMs.
-
-See [this notebook](/docs/integrations/memory/momento_chat_message_history) for a walkthrough of how to use Momento as a memory store for chat message history.
-
-```python
-from langchain.memory import MomentoChatMessageHistory
-```
-
-## Vector Store
-
-Momento Vector Index (MVI) can be used as a vector store.
-
-See [this notebook](/docs/integrations/vectorstores/momento_vector_index) for a walkthrough of how to use MVI as a vector store.
-
-```python
-from langchain_community.vectorstores import MomentoVectorIndex
-```

langchain_md_files/integrations/providers/mongodb_atlas.mdx

@@ -1,82 +0,0 @@
-# MongoDB Atlas
-
->[MongoDB Atlas](https://www.mongodb.com/docs/atlas/) is a fully-managed cloud
-> database available in AWS, Azure, and GCP.  It now has support for native 
-> Vector Search on the MongoDB document data.
-
-## Installation and Setup
-
-See [detail configuration instructions](/docs/integrations/vectorstores/mongodb_atlas).
-
-We need to install `langchain-mongodb` python package.
-
-```bash
-pip install langchain-mongodb
-```
-
-## Vector Store
-
-See a [usage example](/docs/integrations/vectorstores/mongodb_atlas).
-
-```python
-from langchain_mongodb import MongoDBAtlasVectorSearch
-```
-
-
-## LLM Caches
-
-### MongoDBCache
-An abstraction to store a simple cache in MongoDB. This does not use Semantic Caching, nor does it require an index to be made on the collection before generation.
-
-To import this cache:
-```python
-from langchain_mongodb.cache import MongoDBCache
-```
-
-To use this cache with your LLMs:
-```python
-from langchain_core.globals import set_llm_cache
-
-# use any embedding provider...
-from tests.integration_tests.vectorstores.fake_embeddings import FakeEmbeddings
-
-mongodb_atlas_uri = "<YOUR_CONNECTION_STRING>"
-COLLECTION_NAME="<YOUR_CACHE_COLLECTION_NAME>"
-DATABASE_NAME="<YOUR_DATABASE_NAME>"
-
-set_llm_cache(MongoDBCache(
-    connection_string=mongodb_atlas_uri,
-    collection_name=COLLECTION_NAME,
-    database_name=DATABASE_NAME,
-))
-```
-
-
-### MongoDBAtlasSemanticCache
-Semantic caching allows users to retrieve cached prompts based on semantic similarity between the user input and previously cached results. Under the hood it blends MongoDBAtlas as both a cache and a vectorstore.
-The MongoDBAtlasSemanticCache inherits from `MongoDBAtlasVectorSearch` and needs an Atlas Vector Search Index defined to work. Please look at the [usage example](/docs/integrations/vectorstores/mongodb_atlas) on how to set up the index.
-
-To import this cache:
-```python
-from langchain_mongodb.cache import MongoDBAtlasSemanticCache
-```
-
-To use this cache with your LLMs:
-```python
-from langchain_core.globals import set_llm_cache
-
-# use any embedding provider...
-from tests.integration_tests.vectorstores.fake_embeddings import FakeEmbeddings
-
-mongodb_atlas_uri = "<YOUR_CONNECTION_STRING>"
-COLLECTION_NAME="<YOUR_CACHE_COLLECTION_NAME>"
-DATABASE_NAME="<YOUR_DATABASE_NAME>"
-
-set_llm_cache(MongoDBAtlasSemanticCache(
-    embedding=FakeEmbeddings(),
-    connection_string=mongodb_atlas_uri,
-    collection_name=COLLECTION_NAME,
-    database_name=DATABASE_NAME,
-))
-```
-``

langchain_md_files/integrations/providers/motherduck.mdx

@@ -1,53 +0,0 @@
-# Motherduck
-
->[Motherduck](https://motherduck.com/) is a managed DuckDB-in-the-cloud service.
-
-## Installation and Setup
-
-First, you need to install `duckdb` python package.
-
-```bash
-pip install duckdb
-```
-
-You will also need to sign up for an account at [Motherduck](https://motherduck.com/)
-
-After that, you should set up a connection string - we mostly integrate with Motherduck through SQLAlchemy.
-The connection string is likely in the form:
-
-```
-token="..."
-
-conn_str = f"duckdb:///md:{token}@my_db"
-```
-
-## SQLChain
-
-You can use the SQLChain to query data in your Motherduck instance in natural language.
-
-```
-from langchain_openai import OpenAI
-from langchain_community.utilities import SQLDatabase
-from langchain_experimental.sql import SQLDatabaseChain
-db = SQLDatabase.from_uri(conn_str)
-db_chain = SQLDatabaseChain.from_llm(OpenAI(temperature=0), db, verbose=True)
-```
-
-From here, see the [SQL Chain](/docs/how_to#qa-over-sql--csv) documentation on how to use.
-
-
-## LLMCache
-
-You can also easily use Motherduck to cache LLM requests.
-Once again this is done through the SQLAlchemy wrapper.
-
-```
-import sqlalchemy
-from langchain.globals import set_llm_cache
-eng = sqlalchemy.create_engine(conn_str)
-set_llm_cache(SQLAlchemyCache(engine=eng))
-```
-
-From here, see the [LLM Caching](/docs/integrations/llm_caching) documentation on how to use.
-
-

langchain_md_files/integrations/providers/motorhead.mdx

@@ -1,16 +0,0 @@
-# Motörhead
-
->[Motörhead](https://github.com/getmetal/motorhead) is a memory server implemented in Rust. It automatically handles incremental summarization in the background and allows for stateless applications.
-
-## Installation and Setup
-
-See instructions at [Motörhead](https://github.com/getmetal/motorhead) for running the server locally.
-
-
-## Memory
-
-See a [usage example](/docs/integrations/memory/motorhead_memory).
-
-```python
-from langchain_community.memory import MotorheadMemory
-```

langchain_md_files/integrations/providers/myscale.mdx

@@ -1,66 +0,0 @@
-# MyScale
-
-This page covers how to use MyScale vector database within LangChain.
-It is broken into two parts: installation and setup, and then references to specific MyScale wrappers.
-
-With MyScale, you can manage both structured and unstructured (vectorized) data, and perform joint queries and analytics on both types of data using SQL. Plus, MyScale's cloud-native OLAP architecture, built on top of ClickHouse, enables lightning-fast data processing even on massive datasets.
-
-## Introduction
-
-[Overview to MyScale and High performance vector search](https://docs.myscale.com/en/overview/)
-
-You can now register on our SaaS and [start a cluster now!](https://docs.myscale.com/en/quickstart/)
-
-If you are also interested in how we managed to integrate SQL and vector, please refer to [this document](https://docs.myscale.com/en/vector-reference/) for further syntax reference.
-
-We also deliver with live demo on huggingface! Please checkout our [huggingface space](https://huggingface.co/myscale)! They search millions of vector within a blink!
-
-## Installation and Setup
-- Install the Python SDK with `pip install clickhouse-connect`
-
-### Setting up environments
-
-There are two ways to set up parameters for myscale index.
-
-1. Environment Variables
-
-    Before you run the app, please set the environment variable with `export`:
-    `export MYSCALE_HOST='<your-endpoints-url>' MYSCALE_PORT=<your-endpoints-port> MYSCALE_USERNAME=<your-username> MYSCALE_PASSWORD=<your-password> ...`
-
-    You can easily find your account, password and other info on our SaaS. For details please refer to [this document](https://docs.myscale.com/en/cluster-management/)
-    Every attributes under `MyScaleSettings` can be set with prefix `MYSCALE_` and is case insensitive.
-
-2. Create `MyScaleSettings` object with parameters
-
-
-    ```python
-    from langchain_community.vectorstores import MyScale, MyScaleSettings
-    config = MyScaleSettings(host="<your-backend-url>", port=8443, ...)
-    index = MyScale(embedding_function, config)
-    index.add_documents(...)
-    ```
-  
-## Wrappers
-supported functions:
-- `add_texts`
-- `add_documents`
-- `from_texts`
-- `from_documents`
-- `similarity_search`
-- `asimilarity_search`
-- `similarity_search_by_vector`
-- `asimilarity_search_by_vector`
-- `similarity_search_with_relevance_scores`
-- `delete`
-
-### VectorStore
-
-There exists a wrapper around MyScale database, allowing you to use it as a vectorstore,
-whether for semantic search or similar example retrieval.
-
-To import this vectorstore:
-```python
-from langchain_community.vectorstores import MyScale
-```
-
-For a more detailed walkthrough of the MyScale wrapper, see [this notebook](/docs/integrations/vectorstores/myscale)

langchain_md_files/integrations/providers/neo4j.mdx

@@ -1,60 +0,0 @@
-# Neo4j
-
->What is `Neo4j`?
-
->- Neo4j is an `open-source database management system` that specializes in graph database technology.
->- Neo4j allows you to represent and store data in nodes and edges, making it ideal for handling connected data and relationships.
->- Neo4j provides a `Cypher Query Language`, making it easy to interact with and query your graph data.
->- With Neo4j, you can achieve high-performance `graph traversals and queries`, suitable for production-level systems.
-
->Get started with Neo4j by visiting [their website](https://neo4j.com/).
-
-## Installation and Setup
-
-- Install the Python SDK with `pip install neo4j`
-
-
-## VectorStore
-
-The Neo4j vector index is used as a vectorstore,
-whether for semantic search or example selection.
-
-```python
-from langchain_community.vectorstores import Neo4jVector
-```
-
-See a [usage example](/docs/integrations/vectorstores/neo4jvector)
-
-## GraphCypherQAChain
-
-There exists a wrapper around Neo4j graph database that allows you to generate Cypher statements based on the user input
-and use them to retrieve relevant information from the database.
-
-```python
-from langchain_community.graphs import Neo4jGraph
-from langchain.chains import GraphCypherQAChain
-```
-
-See a [usage example](/docs/integrations/graphs/neo4j_cypher)
-
-## Constructing a knowledge graph from text
-
-Text data often contain rich relationships and insights that can be useful for various analytics, recommendation engines, or knowledge management applications.
-Diffbot's NLP API allows for the extraction of entities, relationships, and semantic meaning from unstructured text data.
-By coupling Diffbot's NLP API with Neo4j, a graph database, you can create powerful, dynamic graph structures based on the information extracted from text.
-These graph structures are fully queryable and can be integrated into various applications.
-
-```python
-from langchain_community.graphs import Neo4jGraph
-from langchain_experimental.graph_transformers.diffbot import DiffbotGraphTransformer
-```
-
-See a [usage example](/docs/integrations/graphs/diffbot)
-
-## Memory
-
-See a [usage example](/docs/integrations/memory/neo4j_chat_message_history).
-
-```python
-from langchain.memory import Neo4jChatMessageHistory
-```

langchain_md_files/integrations/providers/nlpcloud.mdx

@@ -1,31 +0,0 @@
-# NLPCloud
-
->[NLP Cloud](https://docs.nlpcloud.com/#introduction) is an artificial intelligence platform that allows you to use the most advanced AI engines, and even train your own engines with your own data. 
-
-
-## Installation and Setup
-
-- Install the `nlpcloud` package.
-
-```bash
-pip install nlpcloud
-```
-
-- Get an NLPCloud api key and set it as an environment variable (`NLPCLOUD_API_KEY`)
-
-
-## LLM
-
-See a [usage example](/docs/integrations/llms/nlpcloud).
-
-```python
-from langchain_community.llms import NLPCloud
-```
-
-## Text Embedding Models
-
-See a [usage example](/docs/integrations/text_embedding/nlp_cloud)
-
-```python
-from langchain_community.embeddings import NLPCloudEmbeddings
-```

langchain_md_files/integrations/providers/notion.mdx

@@ -1,20 +0,0 @@
-# Notion DB
-
->[Notion](https://www.notion.so/) is a collaboration platform with modified Markdown support that integrates kanban 
-> boards, tasks, wikis and databases. It is an all-in-one workspace for notetaking, knowledge and data management, 
-> and project and task management.
-
-## Installation and Setup
-
-All instructions are in examples below.
-
-## Document Loader
-
-We have two different loaders: `NotionDirectoryLoader` and `NotionDBLoader`.
-
-See [usage examples here](/docs/integrations/document_loaders/notion).
-
-
-```python
-from langchain_community.document_loaders import NotionDirectoryLoader, NotionDBLoader
-```

langchain_md_files/integrations/providers/nuclia.mdx

@@ -1,78 +0,0 @@
-# Nuclia
-
->[Nuclia](https://nuclia.com) automatically indexes your unstructured data from any internal
-> and external source, providing optimized search results and generative answers. 
-> It can handle video and audio transcription, image content extraction, and document parsing.
-
-
-
-## Installation and Setup
-
-We need to install the `nucliadb-protos` package to use the `Nuclia Understanding API`
-
-```bash
-pip install nucliadb-protos
-```
-
-We need to have a `Nuclia account`. 
-We can create one for free at [https://nuclia.cloud](https://nuclia.cloud), 
-and then [create a NUA key](https://docs.nuclia.dev/docs/docs/using/understanding/intro).
-
-
-## Document Transformer
-
-### Nuclia
-
->`Nuclia Understanding API` document transformer splits text into paragraphs and sentences, 
-> identifies entities, provides a summary of the text and generates embeddings for all the sentences.
-
-To use the Nuclia document transformer, we need to instantiate a `NucliaUnderstandingAPI`
-tool with `enable_ml` set to `True`:
-
-```python
-from langchain_community.tools.nuclia import NucliaUnderstandingAPI
-
-nua = NucliaUnderstandingAPI(enable_ml=True)
-```
-
-See a [usage example](/docs/integrations/document_transformers/nuclia_transformer).
-
-```python
-from langchain_community.document_transformers.nuclia_text_transform import NucliaTextTransformer
-```
-
-## Document Loaders
-
-### Nuclea loader
-
-See a [usage example](/docs/integrations/document_loaders/nuclia).
-
-```python
-from langchain_community.document_loaders.nuclia import NucliaLoader
-```
-
-## Vector store
-
-### NucliaDB
-
-We need to install a python package:
-
-```bash
-pip install nuclia
-```
-
-See a [usage example](/docs/integrations/vectorstores/nucliadb).
-
-```python
-from langchain_community.vectorstores.nucliadb import NucliaDB
-```
-
-## Tools
-
-### Nuclia Understanding
-
-See a [usage example](/docs/integrations/tools/nuclia).
-
-```python
-from langchain_community.tools.nuclia import NucliaUnderstandingAPI
-```

langchain_md_files/integrations/providers/nvidia.mdx

@@ -1,82 +0,0 @@
-# NVIDIA
-The `langchain-nvidia-ai-endpoints` package contains LangChain integrations building applications with models on 
-NVIDIA NIM inference microservice. NIM supports models across domains like chat, embedding, and re-ranking models 
-from the community as well as NVIDIA. These models are optimized by NVIDIA to deliver the best performance on NVIDIA 
-accelerated infrastructure and deployed as a NIM, an easy-to-use, prebuilt containers that deploy anywhere using a single 
-command on NVIDIA accelerated infrastructure.
-
-NVIDIA hosted deployments of NIMs are available to test on the [NVIDIA API catalog](https://build.nvidia.com/). After testing, 
-NIMs can be exported from NVIDIA’s API catalog using the NVIDIA AI Enterprise license and run on-premises or in the cloud, 
-giving enterprises ownership and full control of their IP and AI application.
-
-NIMs are packaged as container images on a per model basis and are distributed as NGC container images through the NVIDIA NGC Catalog. 
-At their core, NIMs provide easy, consistent, and familiar APIs for running inference on an AI model.
-
-Below is an example on how to use some common functionality surrounding text-generative and embedding models.
-
-## Installation
-
-```python
-pip install -U --quiet langchain-nvidia-ai-endpoints
-```
-
-## Setup
-
-**To get started:**
-
-1. Create a free account with [NVIDIA](https://build.nvidia.com/), which hosts NVIDIA AI Foundation models.
-
-2. Click on your model of choice.
-
-3. Under Input select the Python tab, and click `Get API Key`. Then click `Generate Key`.
-
-4. Copy and save the generated key as NVIDIA_API_KEY. From there, you should have access to the endpoints.
-
-```python
-import getpass
-import os
-
-if not os.environ.get("NVIDIA_API_KEY", "").startswith("nvapi-"):
-    nvidia_api_key = getpass.getpass("Enter your NVIDIA API key: ")
-    assert nvidia_api_key.startswith("nvapi-"), f"{nvidia_api_key[:5]}... is not a valid key"
-    os.environ["NVIDIA_API_KEY"] = nvidia_api_key
-```
-## Working with NVIDIA API Catalog
-
-```python
-from langchain_nvidia_ai_endpoints import ChatNVIDIA
-
-llm = ChatNVIDIA(model="mistralai/mixtral-8x22b-instruct-v0.1")
-result = llm.invoke("Write a ballad about LangChain.")
-print(result.content)
-```
-
-Using the API, you can query live endpoints available on the NVIDIA API Catalog to get quick results from a DGX-hosted cloud compute environment. All models are source-accessible and can be deployed on your own compute cluster using NVIDIA NIM which is part of NVIDIA AI Enterprise, shown in the next section [Working with NVIDIA NIMs](##working-with-nvidia-nims). 
-
-## Working with NVIDIA NIMs
-When ready to deploy, you can self-host models with NVIDIA NIM—which is included with the NVIDIA AI Enterprise software license—and run them anywhere, giving you ownership of your customizations and full control of your intellectual property (IP) and AI applications.
-
-[Learn more about NIMs](https://developer.nvidia.com/blog/nvidia-nim-offers-optimized-inference-microservices-for-deploying-ai-models-at-scale/)
-
-```python
-from langchain_nvidia_ai_endpoints import ChatNVIDIA, NVIDIAEmbeddings, NVIDIARerank
-
-# connect to a chat NIM running at localhost:8000, specifying a model
-llm = ChatNVIDIA(base_url="http://localhost:8000/v1", model="meta/llama3-8b-instruct")
-
-# connect to an embedding NIM running at localhost:8080
-embedder = NVIDIAEmbeddings(base_url="http://localhost:8080/v1")
-
-# connect to a reranking NIM running at localhost:2016
-ranker = NVIDIARerank(base_url="http://localhost:2016/v1")
-```
-
-## Using NVIDIA AI Foundation Endpoints
-
-A selection of NVIDIA AI Foundation models are supported directly in LangChain with familiar APIs.
-
-The active models which are supported can be found [in API Catalog](https://build.nvidia.com/).
-
-**The following may be useful examples to help you get started:**
-- **[`ChatNVIDIA` Model](/docs/integrations/chat/nvidia_ai_endpoints).**
-- **[`NVIDIAEmbeddings` Model for RAG Workflows](/docs/integrations/text_embedding/nvidia_ai_endpoints).**

langchain_md_files/integrations/providers/obsidian.mdx

@@ -1,19 +0,0 @@
-# Obsidian
-
->[Obsidian](https://obsidian.md/) is a powerful and extensible knowledge base
-that works on top of your local folder of plain text files.
-
-## Installation and Setup
-
-All instructions are in examples below.
-
-## Document Loader
-
-
-See a [usage example](/docs/integrations/document_loaders/obsidian).
-
-
-```python
-from langchain_community.document_loaders import ObsidianLoader
-```
-

langchain_md_files/integrations/providers/oci.mdx

@@ -1,51 +0,0 @@
-# Oracle Cloud Infrastructure (OCI)
-
-The `LangChain` integrations related to [Oracle Cloud Infrastructure](https://www.oracle.com/artificial-intelligence/).
-
-## OCI Generative AI
-> Oracle Cloud Infrastructure (OCI) [Generative AI](https://docs.oracle.com/en-us/iaas/Content/generative-ai/home.htm) is a fully managed service that provides a set of state-of-the-art,
-> customizable large language models (LLMs) that cover a wide range of use cases, and which are available through a single API.
-> Using the OCI Generative AI service you can access ready-to-use pretrained models, or create and host your own fine-tuned
-> custom models based on your own data on dedicated AI clusters. 
-
-To use, you should have the latest `oci` python SDK and the langchain_community package installed.
-
-```bash
-pip install -U oci langchain-community
-```
-
-See [chat](/docs/integrations/llms/oci_generative_ai), [complete](/docs/integrations/chat/oci_generative_ai), and [embedding](/docs/integrations/text_embedding/oci_generative_ai) usage examples.
-
-```python
-from langchain_community.chat_models import ChatOCIGenAI
-
-from langchain_community.llms import OCIGenAI
-
-from langchain_community.embeddings import OCIGenAIEmbeddings
-```
-
-## OCI Data Science Model Deployment Endpoint
-
-> [OCI Data Science](https://docs.oracle.com/en-us/iaas/data-science/using/home.htm) is a
-> fully managed and serverless platform for data science teams. Using the OCI Data Science
-> platform you can build, train, and manage machine learning models, and then deploy them
-> as an OCI Model Deployment Endpoint using the
-> [OCI Data Science Model Deployment Service](https://docs.oracle.com/en-us/iaas/data-science/using/model-dep-about.htm).
-
-If you deployed a LLM with the VLLM or TGI framework, you can use the
-`OCIModelDeploymentVLLM` or `OCIModelDeploymentTGI` classes to interact with it.
-
-To use, you should have the latest `oracle-ads` python SDK installed.
-
-```bash
-pip install -U oracle-ads
-```
-
-See [usage examples](/docs/integrations/llms/oci_model_deployment_endpoint).
-
-```python
-from langchain_community.llms import OCIModelDeploymentVLLM
-
-from langchain_community.llms import OCIModelDeploymentTGI
-```
-

langchain_md_files/integrations/providers/octoai.mdx

@@ -1,37 +0,0 @@
-# OctoAI
-
->[OctoAI](https://docs.octoai.cloud/docs) offers easy access to efficient compute 
-> and enables users to integrate their choice of AI models into applications. 
-> The `OctoAI` compute service helps you run, tune, and scale AI applications easily.
-
-
-## Installation and Setup
-
-- Install the `openai` Python package:
-  ```bash
-  pip install openai
-  ````
-- Register on `OctoAI` and get an API Token from [your OctoAI account page](https://octoai.cloud/settings).
-
-
-## Chat models
-
-See a [usage example](/docs/integrations/chat/octoai).
-
-```python
-from langchain_community.chat_models import ChatOctoAI
-```
-
-## LLMs
-
-See a [usage example](/docs/integrations/llms/octoai).
-
-```python
-from langchain_community.llms.octoai_endpoint import OctoAIEndpoint
-```
-
-## Embedding models
-
-```python
-from langchain_community.embeddings.octoai_embeddings import OctoAIEmbeddings
-```

langchain_md_files/integrations/providers/ollama.mdx

@@ -1,73 +0,0 @@
-# Ollama
-
->[Ollama](https://ollama.com/) allows you to run open-source large language models, 
-> such as [Llama3.1](https://ai.meta.com/blog/meta-llama-3-1/), locally.
->
->`Ollama` bundles model weights, configuration, and data into a single package, defined by a Modelfile. 
->It optimizes setup and configuration details, including GPU usage.
->For a complete list of supported models and model variants, see the [Ollama model library](https://ollama.ai/library).
-
-See [this guide](/docs/how_to/local_llms) for more details
-on how to use `Ollama` with LangChain.
-
-## Installation and Setup
-### Ollama installation
-Follow [these instructions](https://github.com/ollama/ollama?tab=readme-ov-file#ollama) 
-to set up and run a local Ollama instance.
-
-Ollama will start as a background service automatically, if this is disabled, run:
-
-```bash
-# export OLLAMA_HOST=127.0.0.1 # environment variable to set ollama host
-# export OLLAMA_PORT=11434 # environment variable to set the ollama port
-ollama serve
-```
-
-After starting ollama, run `ollama pull <model_checkpoint>` to download a model 
-from the [Ollama model library](https://ollama.ai/library).
-
-```bash
-ollama pull llama3.1
-```
-
-We're now ready to install the `langchain-ollama` partner package and run a model.
-
-### Ollama LangChain partner package install
-Install the integration package with:
-```bash
-pip install langchain-ollama
-```
-## LLM
-
-```python
-from langchain_ollama.llms import OllamaLLM
-```
-
-See the notebook example [here](/docs/integrations/llms/ollama).
-
-## Chat Models
-
-### Chat Ollama
-
-```python
-from langchain_ollama.chat_models import ChatOllama
-```
-
-See the notebook example [here](/docs/integrations/chat/ollama).
-
-### Ollama tool calling
-[Ollama tool calling](https://ollama.com/blog/tool-support) uses the
-OpenAI compatible web server specification, and can be used with
-the default `BaseChatModel.bind_tools()` methods
-as described [here](/docs/how_to/tool_calling/).
-Make sure to select an ollama model that supports [tool calling](https://ollama.com/search?&c=tools).
-
-## Embedding models
-
-```python
-from langchain_community.embeddings import OllamaEmbeddings
-```
-
-See the notebook example [here](/docs/integrations/text_embedding/ollama).
-
-

langchain_md_files/integrations/providers/ontotext_graphdb.mdx

@@ -1,21 +0,0 @@
-# Ontotext GraphDB
-
->[Ontotext GraphDB](https://graphdb.ontotext.com/) is a graph database and knowledge discovery tool compliant with RDF and SPARQL.
-
-## Dependencies
-
-Install the [rdflib](https://github.com/RDFLib/rdflib) package with
-```bash
-pip install rdflib==7.0.0
-```
-
-## Graph QA Chain
-
-Connect your GraphDB Database with a chat model to get insights on your data.
-
-See the notebook example [here](/docs/integrations/graphs/ontotext).
-
-```python
-from langchain_community.graphs import OntotextGraphDBGraph
-from langchain.chains import OntotextGraphDBQAChain
-```

langchain_md_files/integrations/providers/openllm.mdx

@@ -1,70 +0,0 @@
-# OpenLLM
-
-This page demonstrates how to use [OpenLLM](https://github.com/bentoml/OpenLLM)
-with LangChain.
-
-`OpenLLM` is an open platform for operating large language models (LLMs) in
-production. It enables developers to easily run inference with any open-source
-LLMs, deploy to the cloud or on-premises, and build powerful AI apps.
-
-## Installation and Setup
-
-Install the OpenLLM package via PyPI:
-
-```bash
-pip install openllm
-```
-
-## LLM
-
-OpenLLM supports a wide range of open-source LLMs as well as serving users' own
-fine-tuned LLMs. Use `openllm model` command to see all available models that
-are pre-optimized for OpenLLM.
-
-## Wrappers
-
-There is a OpenLLM Wrapper which supports loading LLM in-process or accessing a
-remote OpenLLM server:
-
-```python
-from langchain_community.llms import OpenLLM
-```
-
-### Wrapper for OpenLLM server
-
-This wrapper supports connecting to an OpenLLM server via HTTP or gRPC. The
-OpenLLM server can run either locally or on the cloud.
-
-To try it out locally, start an OpenLLM server:
-
-```bash
-openllm start flan-t5
-```
-
-Wrapper usage:
-
-```python
-from langchain_community.llms import OpenLLM
-
-llm = OpenLLM(server_url='http://localhost:3000')
-
-llm("What is the difference between a duck and a goose? And why there are so many Goose in Canada?")
-```
-
-### Wrapper for Local Inference
-
-You can also use the OpenLLM wrapper to load LLM in current Python process for
-running inference.
-
-```python
-from langchain_community.llms import OpenLLM
-
-llm = OpenLLM(model_name="dolly-v2", model_id='databricks/dolly-v2-7b')
-
-llm("What is the difference between a duck and a goose? And why there are so many Goose in Canada?")
-```
-
-### Usage
-
-For a more detailed walkthrough of the OpenLLM Wrapper, see the
-[example notebook](/docs/integrations/llms/openllm)

langchain_md_files/integrations/providers/opensearch.mdx

@@ -1,21 +0,0 @@
-# OpenSearch
-
-This page covers how to use the OpenSearch ecosystem within LangChain.
-It is broken into two parts: installation and setup, and then references to specific OpenSearch wrappers.
-
-## Installation and Setup
-- Install the Python package with `pip install opensearch-py`
-## Wrappers
-
-### VectorStore
-
-There exists a wrapper around OpenSearch vector databases, allowing you to use it as a vectorstore 
-for semantic search using approximate vector search powered by lucene, nmslib and faiss engines 
-or using painless scripting and script scoring functions for bruteforce vector search.
-
-To import this vectorstore:
-```python
-from langchain_community.vectorstores import OpenSearchVectorSearch
-```
-
-For a more detailed walkthrough of the OpenSearch wrapper, see [this notebook](/docs/integrations/vectorstores/opensearch)

langchain_md_files/integrations/providers/openweathermap.mdx

@@ -1,44 +0,0 @@
-# OpenWeatherMap
-
->[OpenWeatherMap](https://openweathermap.org/api/) provides all essential weather data for a specific location:
->- Current weather
->- Minute forecast for 1 hour
->- Hourly forecast for 48 hours
->- Daily forecast for 8 days
->- National weather alerts
->- Historical weather data for 40+ years back
-
-This page covers how to use the `OpenWeatherMap API` within LangChain.
-
-## Installation and Setup
-
-- Install requirements with
-```bash
-pip install pyowm
-```
-- Go to OpenWeatherMap and sign up for an account to get your API key [here](https://openweathermap.org/api/)
-- Set your API key as `OPENWEATHERMAP_API_KEY` environment variable
-
-## Wrappers
-
-### Utility
-
-There exists a OpenWeatherMapAPIWrapper utility which wraps this API. To import this utility:
-
-```python
-from langchain_community.utilities.openweathermap import OpenWeatherMapAPIWrapper
-```
-
-For a more detailed walkthrough of this wrapper, see [this notebook](/docs/integrations/tools/openweathermap).
-
-### 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(["openweathermap-api"])
-```
-
-For more information on tools, see [this page](/docs/how_to/tools_builtin).

langchain_md_files/integrations/providers/oracleai.mdx

@@ -1,67 +0,0 @@
-# OracleAI Vector Search
-
-Oracle AI Vector Search is designed for Artificial Intelligence (AI) workloads that allows you to query data based on semantics, rather than keywords.
-One of the biggest benefits of Oracle AI Vector Search is that semantic search on unstructured data can be combined with relational search on business data in one single system.
-This is not only powerful but also significantly more effective because you don't need to add a specialized vector database, eliminating the pain of data fragmentation between multiple systems.
-
-In addition, your vectors can benefit from all of Oracle Database’s most powerful features, like the following:
-
- * [Partitioning Support](https://www.oracle.com/database/technologies/partitioning.html)
- * [Real Application Clusters scalability](https://www.oracle.com/database/real-application-clusters/)
- * [Exadata smart scans](https://www.oracle.com/database/technologies/exadata/software/smartscan/)
- * [Shard processing across geographically distributed databases](https://www.oracle.com/database/distributed-database/)
- * [Transactions](https://docs.oracle.com/en/database/oracle/oracle-database/23/cncpt/transactions.html)
- * [Parallel SQL](https://docs.oracle.com/en/database/oracle/oracle-database/21/vldbg/parallel-exec-intro.html#GUID-D28717E4-0F77-44F5-BB4E-234C31D4E4BA)
- * [Disaster recovery](https://www.oracle.com/database/data-guard/)
- * [Security](https://www.oracle.com/security/database-security/)
- * [Oracle Machine Learning](https://www.oracle.com/artificial-intelligence/database-machine-learning/)
- * [Oracle Graph Database](https://www.oracle.com/database/integrated-graph-database/)
- * [Oracle Spatial and Graph](https://www.oracle.com/database/spatial/)
- * [Oracle Blockchain](https://docs.oracle.com/en/database/oracle/oracle-database/23/arpls/dbms_blockchain_table.html#GUID-B469E277-978E-4378-A8C1-26D3FF96C9A6)
- * [JSON](https://docs.oracle.com/en/database/oracle/oracle-database/23/adjsn/json-in-oracle-database.html)
-
-
-## Document Loaders
-
-Please check the [usage example](/docs/integrations/document_loaders/oracleai).
-
-```python
-from langchain_community.document_loaders.oracleai import OracleDocLoader
-```
-
-## Text Splitter
-
-Please check the [usage example](/docs/integrations/document_loaders/oracleai).
-
-```python
-from langchain_community.document_loaders.oracleai import OracleTextSplitter
-```
-
-## Embeddings
-
-Please check the [usage example](/docs/integrations/text_embedding/oracleai).
-
-```python
-from langchain_community.embeddings.oracleai import OracleEmbeddings
-```
-
-## Summary
-
-Please check the [usage example](/docs/integrations/tools/oracleai).
-
-```python
-from langchain_community.utilities.oracleai import OracleSummary
-```
-
-## Vector Store
-
-Please check the [usage example](/docs/integrations/vectorstores/oracle).
-
-```python
-from langchain_community.vectorstores.oraclevs import OracleVS
-```
-
-## End to End Demo
-
-Please check the [Oracle AI Vector Search End-to-End Demo Guide](https://github.com/langchain-ai/langchain/blob/master/cookbook/oracleai_demo.ipynb).
-