Datasets:

seansullivan

/

Langchain-Docs

like 0

https://python.langchain.com/docs/integrations/providers/cloudflare/

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

Cloudflare Cloudflare, Inc. (Wikipedia) is an American company that provides content delivery network services, cloud cybersecurity, DDoS mitigation, and ICANN-accredited domain registration services. Cloudflare Workers AI allows you to run machine learning models, on the Cloudflare network, from your code via REST API. Embedding models​ See installation instructions and usage example. from langchain_community.embeddings.cloudflare_workersai import CloudflareWorkersAIEmbeddings

https://python.langchain.com/docs/integrations/providers/clarifai/

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

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

https://python.langchain.com/docs/integrations/providers/clickhouse/

We need to install `clickhouse-connect` python package. ``` from langchain_community.vectorstores import Clickhouse, ClickhouseSettings ```

We need to install clickhouse-connect python package. from langchain_community.vectorstores import Clickhouse, ClickhouseSettings

https://python.langchain.com/docs/integrations/providers/aleph_alpha/

## Aleph Alpha > [Aleph Alpha](https://docs.aleph-alpha.com/) was founded in 2019 with the mission to research and build the foundational technology for an era of strong AI. The team of international scientists, engineers, and innovators researches, develops, and deploys transformative AI like large language and multimodal models and runs the fastest European commercial AI cluster. > [The Luminous series](https://docs.aleph-alpha.com/docs/introduction/luminous/) is a family of large language models. ## Installation and Setup[​](#installation-and-setup "Direct link to Installation and Setup") ``` pip install aleph-alpha-client ``` You have to create a new token. Please, see [instructions](https://docs.aleph-alpha.com/docs/account/#create-a-new-token). ``` from getpass import getpassALEPH_ALPHA_API_KEY = getpass() ``` ## LLM[​](#llm "Direct link to LLM") See a [usage example](https://python.langchain.com/docs/integrations/llms/aleph_alpha/). ``` from langchain_community.llms import AlephAlpha ``` ## Text Embedding Models[​](#text-embedding-models "Direct link to Text Embedding Models") See a [usage example](https://python.langchain.com/docs/integrations/text_embedding/aleph_alpha/). ``` from langchain_community.embeddings import AlephAlphaSymmetricSemanticEmbedding, AlephAlphaAsymmetricSemanticEmbedding ``` * * * #### Help us out by providing feedback on this documentation page:

Aleph Alpha Aleph Alpha was founded in 2019 with the mission to research and build the foundational technology for an era of strong AI. The team of international scientists, engineers, and innovators researches, develops, and deploys transformative AI like large language and multimodal models and runs the fastest European commercial AI cluster. The Luminous series is a family of large language models. Installation and Setup​ pip install aleph-alpha-client You have to create a new token. Please, see instructions. from getpass import getpass ALEPH_ALPHA_API_KEY = getpass() LLM​ See a usage example. from langchain_community.llms import AlephAlpha Text Embedding Models​ See a usage example. from langchain_community.embeddings import AlephAlphaSymmetricSemanticEmbedding, AlephAlphaAsymmetricSemanticEmbedding Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/analyticdb/

This page covers how to use the AnalyticDB ecosystem within LangChain. You need to install the `sqlalchemy` python package. ``` from langchain_community.vectorstores import AnalyticDB ```

This page covers how to use the AnalyticDB ecosystem within LangChain. You need to install the sqlalchemy python package. from langchain_community.vectorstores import AnalyticDB

https://python.langchain.com/docs/integrations/providers/annoy/

## Annoy > [Annoy](https://github.com/spotify/annoy) (`Approximate Nearest Neighbors Oh Yeah`) is a C++ library with Python bindings to search for points in space that are close to a given query point. It also creates large read-only file-based data structures that are mapped into memory so that many processes may share the same data. ## Installation and Setup[​](#installation-and-setup "Direct link to Installation and Setup") ## Vectorstore[​](#vectorstore "Direct link to Vectorstore") See a [usage example](https://python.langchain.com/docs/integrations/vectorstores/annoy/). ``` from langchain_community.vectorstores import Annoy ``` * * * #### Help us out by providing feedback on this documentation page:

Annoy Annoy (Approximate Nearest Neighbors Oh Yeah) is a C++ library with Python bindings to search for points in space that are close to a given query point. It also creates large read-only file-based data structures that are mapped into memory so that many processes may share the same data. Installation and Setup​ Vectorstore​ See a usage example. from langchain_community.vectorstores import Annoy Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/anyscale/

`Anyscale` also provides [an example](https://docs.anyscale.com/endpoints/model-serving/examples/langchain-integration) how to setup `LangChain` with `Anyscale` for advanced chat agents. ``` from langchain_community.llms.anyscale import Anyscale ```

Anyscale also provides an example how to setup LangChain with Anyscale for advanced chat agents. from langchain_community.llms.anyscale import Anyscale

https://python.langchain.com/docs/integrations/providers/cnosdb/

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

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

https://python.langchain.com/docs/integrations/providers/cohere/

## Cohere > [Cohere](https://cohere.ai/about) is a Canadian startup that provides natural language processing models that help companies improve human-machine interactions. ## Installation and Setup[​](#installation-and-setup "Direct link to Installation and Setup") * Install the Python SDK : ``` pip install langchain-cohere ``` Get a [Cohere api key](https://dashboard.cohere.ai/) and set it as an environment variable (`COHERE_API_KEY`) ## Cohere langchain integrations[​](#cohere-langchain-integrations "Direct link to Cohere langchain integrations") | API | description | Endpoint docs | Import | Example usage | | --- | --- | --- | --- | --- | | Chat | Build chat bots | [chat](https://docs.cohere.com/reference/chat) | `from langchain_cohere import ChatCohere` | [cohere.ipynb](https://python.langchain.com/docs/integrations/chat/cohere/) | | LLM | Generate text | [generate](https://docs.cohere.com/reference/generate) | `from langchain_cohere.llms import Cohere` | [cohere.ipynb](https://python.langchain.com/docs/integrations/llms/cohere/) | | RAG Retriever | Connect to external data sources | [chat + rag](https://docs.cohere.com/reference/chat) | `from langchain.retrievers import CohereRagRetriever` | [cohere.ipynb](https://python.langchain.com/docs/integrations/retrievers/cohere/) | | Text Embedding | Embed strings to vectors | [embed](https://docs.cohere.com/reference/embed) | `from langchain_cohere import CohereEmbeddings` | [cohere.ipynb](https://python.langchain.com/docs/integrations/text_embedding/cohere/) | | Rerank Retriever | Rank strings based on relevance | [rerank](https://docs.cohere.com/reference/rerank) | `from langchain.retrievers.document_compressors import CohereRerank` | [cohere.ipynb](https://python.langchain.com/docs/integrations/retrievers/cohere-reranker/) | ## Quick copy examples[​](#quick-copy-examples "Direct link to Quick copy examples") ### Chat[​](#chat "Direct link to Chat") ``` from langchain_cohere import ChatCoherefrom langchain_core.messages import HumanMessagechat = ChatCohere()messages = [HumanMessage(content="knock knock")]print(chat.invoke(messages)) ``` Usage of the Cohere [chat model](https://python.langchain.com/docs/integrations/chat/cohere/) ### LLM[​](#llm "Direct link to LLM") ``` from langchain_cohere.llms import Coherellm = Cohere()print(llm.invoke("Come up with a pet name")) ``` Usage of the Cohere (legacy) [LLM model](https://python.langchain.com/docs/integrations/llms/cohere/) ### ReAct Agent[​](#react-agent "Direct link to ReAct Agent") ``` from langchain_community.tools.tavily_search import TavilySearchResultsfrom langchain_cohere import ChatCohere, create_cohere_react_agentfrom langchain_core.prompts import ChatPromptTemplatefrom langchain.agents import AgentExecutorllm = ChatCohere()internet_search = TavilySearchResults(max_results=4)internet_search.name = "internet_search"internet_search.description = "Route a user query to the internet"prompt = ChatPromptTemplate.from_template("{input}")agent = create_cohere_react_agent( llm, [internet_search], prompt)agent_executor = AgentExecutor(agent=agent, tools=[internet_search], verbose=True)agent_executor.invoke({ "input": "In what year was the company that was founded as Sound of Music added to the S&P 500?",}) ``` ### RAG Retriever[​](#rag-retriever "Direct link to RAG Retriever") ``` from langchain_cohere import ChatCoherefrom langchain.retrievers import CohereRagRetrieverfrom langchain_core.documents import Documentrag = CohereRagRetriever(llm=ChatCohere())print(rag.get_relevant_documents("What is cohere ai?")) ``` Usage of the Cohere [RAG Retriever](https://python.langchain.com/docs/integrations/retrievers/cohere/) ### Text Embedding[​](#text-embedding "Direct link to Text Embedding") ``` from langchain_cohere import CohereEmbeddingsembeddings = CohereEmbeddings(model="embed-english-light-v3.0")print(embeddings.embed_documents(["This is a test document."])) ``` Usage of the Cohere [Text Embeddings model](https://python.langchain.com/docs/integrations/text_embedding/cohere/) ### Reranker[​](#reranker "Direct link to Reranker") Usage of the Cohere [Reranker](https://python.langchain.com/docs/integrations/retrievers/cohere-reranker/)

Cohere Cohere is a Canadian startup that provides natural language processing models that help companies improve human-machine interactions. Installation and Setup​ Install the Python SDK : pip install langchain-cohere Get a Cohere api key and set it as an environment variable (COHERE_API_KEY) Cohere langchain integrations​ APIdescriptionEndpoint docsImportExample usage Chat Build chat bots chat from langchain_cohere import ChatCohere cohere.ipynb LLM Generate text generate from langchain_cohere.llms import Cohere cohere.ipynb RAG Retriever Connect to external data sources chat + rag from langchain.retrievers import CohereRagRetriever cohere.ipynb Text Embedding Embed strings to vectors embed from langchain_cohere import CohereEmbeddings cohere.ipynb Rerank Retriever Rank strings based on relevance rerank from langchain.retrievers.document_compressors import CohereRerank cohere.ipynb Quick copy examples​ Chat​ from langchain_cohere import ChatCohere from langchain_core.messages import HumanMessage chat = ChatCohere() messages = [HumanMessage(content="knock knock")] print(chat.invoke(messages)) Usage of the Cohere chat model LLM​ from langchain_cohere.llms import Cohere llm = Cohere() print(llm.invoke("Come up with a pet name")) Usage of the Cohere (legacy) LLM model ReAct Agent​ from langchain_community.tools.tavily_search import TavilySearchResults from langchain_cohere import ChatCohere, create_cohere_react_agent from langchain_core.prompts import ChatPromptTemplate from langchain.agents import AgentExecutor llm = ChatCohere() internet_search = TavilySearchResults(max_results=4) internet_search.name = "internet_search" internet_search.description = "Route a user query to the internet" prompt = ChatPromptTemplate.from_template("{input}") agent = create_cohere_react_agent( llm, [internet_search], prompt ) agent_executor = AgentExecutor(agent=agent, tools=[internet_search], verbose=True) agent_executor.invoke({ "input": "In what year was the company that was founded as Sound of Music added to the S&P 500?", }) RAG Retriever​ from langchain_cohere import ChatCohere from langchain.retrievers import CohereRagRetriever from langchain_core.documents import Document rag = CohereRagRetriever(llm=ChatCohere()) print(rag.get_relevant_documents("What is cohere ai?")) Usage of the Cohere RAG Retriever Text Embedding​ from langchain_cohere import CohereEmbeddings embeddings = CohereEmbeddings(model="embed-english-light-v3.0") print(embeddings.embed_documents(["This is a test document."])) Usage of the Cohere Text Embeddings model Reranker​ Usage of the Cohere Reranker

https://python.langchain.com/docs/integrations/providers/apache_doris/

## Apache Doris > [Apache Doris](https://doris.apache.org/) is a modern data warehouse for real-time analytics. It delivers lightning-fast analytics on real-time data at scale. > Usually `Apache Doris` is categorized into OLAP, and it has showed excellent performance in [ClickBench — a Benchmark For Analytical DBMS](https://benchmark.clickhouse.com/). Since it has a super-fast vectorized execution engine, it could also be used as a fast vectordb. ## Installation and Setup[​](#installation-and-setup "Direct link to Installation and Setup") ## Vector Store[​](#vector-store "Direct link to Vector Store") See a [usage example](https://python.langchain.com/docs/integrations/vectorstores/apache_doris/). ``` from langchain_community.vectorstores import ApacheDoris ``` * * * #### Help us out by providing feedback on this documentation page:

Apache Doris Apache Doris is a modern data warehouse for real-time analytics. It delivers lightning-fast analytics on real-time data at scale. Usually Apache Doris is categorized into OLAP, and it has showed excellent performance in ClickBench — a Benchmark For Analytical DBMS. Since it has a super-fast vectorized execution engine, it could also be used as a fast vectordb. Installation and Setup​ Vector Store​ See a usage example. from langchain_community.vectorstores import ApacheDoris Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/apify/

This integration enables you run Actors on the `Apify` platform and load their results into LangChain to feed your vector indexes with documents and data from the web, e.g. to generate answers from websites with documentation, blogs, or knowledge bases. You can use the `ApifyWrapper` to run Actors on the Apify platform. ``` from langchain_community.utilities import ApifyWrapper ``` You can also use our `ApifyDatasetLoader` to get data from Apify dataset.

This integration enables you run Actors on the Apify platform and load their results into LangChain to feed your vector indexes with documents and data from the web, e.g. to generate answers from websites with documentation, blogs, or knowledge bases. You can use the ApifyWrapper to run Actors on the Apify platform. from langchain_community.utilities import ApifyWrapper You can also use our ApifyDatasetLoader to get data from Apify dataset.

https://python.langchain.com/docs/integrations/providers/college_confidential/

There isn't any special setup for it. ``` from langchain_community.document_loaders import CollegeConfidentialLoader ```

There isn't any special setup for it. from langchain_community.document_loaders import CollegeConfidentialLoader

https://python.langchain.com/docs/integrations/providers/confident/

## Confident AI > [Confident AI](https://confident-ai.com/) is a creator of the `DeepEval`. > > [DeepEval](https://github.com/confident-ai/deepeval) is a package for unit testing LLMs. Using `DeepEval`, everyone can build robust language models through faster iterations using both unit testing and integration testing. \`DeepEval provides support for each step in the iteration from synthetic data creation to testing. ## Installation and Setup[​](#installation-and-setup "Direct link to Installation and Setup") You need to get the [DeepEval API credentials](https://app.confident-ai.com/). You need to install the `DeepEval` Python package: ## Callbacks[​](#callbacks "Direct link to Callbacks") See an [example](https://python.langchain.com/docs/integrations/callbacks/confident/). ``` from langchain.callbacks.confident_callback import DeepEvalCallbackHandler ``` * * * #### Help us out by providing feedback on this documentation page:

Confident AI Confident AI is a creator of the DeepEval. DeepEval is a package for unit testing LLMs. Using DeepEval, everyone can build robust language models through faster iterations using both unit testing and integration testing. `DeepEval provides support for each step in the iteration from synthetic data creation to testing. Installation and Setup​ You need to get the DeepEval API credentials. You need to install the DeepEval Python package: Callbacks​ See an example. from langchain.callbacks.confident_callback import DeepEvalCallbackHandler Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/context/

## Context > [Context](https://context.ai/) provides user analytics for LLM-powered products and features. ## Installation and Setup[​](#installation-and-setup "Direct link to Installation and Setup") We need to install the `context-python` Python package: ``` pip install context-python ``` ## Callbacks[​](#callbacks "Direct link to Callbacks") See a [usage example](https://python.langchain.com/docs/integrations/callbacks/context/). ``` from langchain.callbacks import ContextCallbackHandler ``` * * * #### Help us out by providing feedback on this documentation page:

Context Context provides user analytics for LLM-powered products and features. Installation and Setup​ We need to install the context-python Python package: pip install context-python Callbacks​ See a usage example. from langchain.callbacks import ContextCallbackHandler Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/comet_tracking/

## Comet > [Comet](https://www.comet.com/) machine learning platform integrates with your existing infrastructure and tools so you can manage, visualize, and optimize models—from training runs to production monitoring  In this guide we will demonstrate how to track your Langchain Experiments, Evaluation Metrics, and LLM Sessions with [Comet](https://www.comet.com/site/?utm_source=langchain&utm_medium=referral&utm_campaign=comet_notebook). [](https://colab.research.google.com/github/hwchase17/langchain/blob/master/docs/ecosystem/comet_tracking) **Example Project:** [Comet with LangChain](https://www.comet.com/examples/comet-example-langchain/view/b5ZThK6OFdhKWVSP3fDfRtrNF/panels?utm_source=langchain&utm_medium=referral&utm_campaign=comet_notebook)  ### Install Comet and Dependencies[​](#install-comet-and-dependencies "Direct link to Install Comet and Dependencies") ``` %pip install --upgrade --quiet comet_ml langchain langchain-openai google-search-results spacy textstat pandas!{sys.executable} -m spacy download en_core_web_sm ``` ### Initialize Comet and Set your Credentials[​](#initialize-comet-and-set-your-credentials "Direct link to Initialize Comet and Set your Credentials") You can grab your [Comet API Key here](https://www.comet.com/signup?utm_source=langchain&utm_medium=referral&utm_campaign=comet_notebook) or click the link after initializing Comet ``` import comet_mlcomet_ml.init(project_name="comet-example-langchain") ``` ### Set OpenAI and SerpAPI credentials[​](#set-openai-and-serpapi-credentials "Direct link to Set OpenAI and SerpAPI credentials") You will need an [OpenAI API Key](https://platform.openai.com/account/api-keys) and a [SerpAPI API Key](https://serpapi.com/dashboard) to run the following examples ``` import osos.environ["OPENAI_API_KEY"] = "..."# os.environ["OPENAI_ORGANIZATION"] = "..."os.environ["SERPAPI_API_KEY"] = "..." ``` ### Scenario 1: Using just an LLM[​](#scenario-1-using-just-an-llm "Direct link to Scenario 1: Using just an LLM") ``` from langchain.callbacks import CometCallbackHandler, StdOutCallbackHandlerfrom langchain_openai import OpenAIcomet_callback = CometCallbackHandler( project_name="comet-example-langchain", complexity_metrics=True, stream_logs=True, tags=["llm"], visualizations=["dep"],)callbacks = [StdOutCallbackHandler(), comet_callback]llm = OpenAI(temperature=0.9, callbacks=callbacks, verbose=True)llm_result = llm.generate(["Tell me a joke", "Tell me a poem", "Tell me a fact"] * 3)print("LLM result", llm_result)comet_callback.flush_tracker(llm, finish=True) ``` ### Scenario 2: Using an LLM in a Chain[​](#scenario-2-using-an-llm-in-a-chain "Direct link to Scenario 2: Using an LLM in a Chain") ``` from langchain.callbacks import CometCallbackHandler, StdOutCallbackHandlerfrom langchain.chains import LLMChainfrom langchain_core.prompts import PromptTemplatefrom langchain_openai import OpenAIcomet_callback = CometCallbackHandler( complexity_metrics=True, project_name="comet-example-langchain", stream_logs=True, tags=["synopsis-chain"],)callbacks = [StdOutCallbackHandler(), comet_callback]llm = OpenAI(temperature=0.9, callbacks=callbacks)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:"""prompt_template = PromptTemplate(input_variables=["title"], template=template)synopsis_chain = LLMChain(llm=llm, prompt=prompt_template, callbacks=callbacks)test_prompts = [{"title": "Documentary about Bigfoot in Paris"}]print(synopsis_chain.apply(test_prompts))comet_callback.flush_tracker(synopsis_chain, finish=True) ``` ### Scenario 3: Using An Agent with Tools[​](#scenario-3-using-an-agent-with-tools "Direct link to Scenario 3: Using An Agent with Tools") ``` from langchain.agents import initialize_agent, load_toolsfrom langchain.callbacks import CometCallbackHandler, StdOutCallbackHandlerfrom langchain_openai import OpenAIcomet_callback = CometCallbackHandler( project_name="comet-example-langchain", complexity_metrics=True, stream_logs=True, tags=["agent"],)callbacks = [StdOutCallbackHandler(), comet_callback]llm = OpenAI(temperature=0.9, callbacks=callbacks)tools = load_tools(["serpapi", "llm-math"], llm=llm, callbacks=callbacks)agent = initialize_agent( tools, llm, agent="zero-shot-react-description", callbacks=callbacks, verbose=True,)agent.run( "Who is Leo DiCaprio's girlfriend? What is her current age raised to the 0.43 power?")comet_callback.flush_tracker(agent, finish=True) ``` ### Scenario 4: Using Custom Evaluation Metrics[​](#scenario-4-using-custom-evaluation-metrics "Direct link to Scenario 4: Using Custom Evaluation Metrics") The `CometCallbackManager` also allows you to define and use Custom Evaluation Metrics to assess generated outputs from your model. Let’s take a look at how this works. In the snippet below, we will use the [ROUGE](https://huggingface.co/spaces/evaluate-metric/rouge) metric to evaluate the quality of a generated summary of an input prompt. ``` %pip install --upgrade --quiet rouge-score ``` ``` from langchain.callbacks import CometCallbackHandler, StdOutCallbackHandlerfrom langchain.chains import LLMChainfrom langchain_core.prompts import PromptTemplatefrom langchain_openai import OpenAIfrom rouge_score import rouge_scorerclass Rouge: def __init__(self, reference): self.reference = reference self.scorer = rouge_scorer.RougeScorer(["rougeLsum"], use_stemmer=True) def compute_metric(self, generation, prompt_idx, gen_idx): prediction = generation.text results = self.scorer.score(target=self.reference, prediction=prediction) return { "rougeLsum_score": results["rougeLsum"].fmeasure, "reference": self.reference, }reference = """The tower is 324 metres (1,063 ft) tall, about the same height as an 81-storey building.It was the first structure to reach a height of 300 metres.It is now taller than the Chrysler Building in New York City by 5.2 metres (17 ft)Excluding transmitters, the Eiffel Tower is the second tallest free-standing structure in France ."""rouge_score = Rouge(reference=reference)template = """Given the following article, it is your job to write a summary.Article:{article}Summary: This is the summary for the above article:"""prompt_template = PromptTemplate(input_variables=["article"], template=template)comet_callback = CometCallbackHandler( project_name="comet-example-langchain", complexity_metrics=False, stream_logs=True, tags=["custom_metrics"], custom_metrics=rouge_score.compute_metric,)callbacks = [StdOutCallbackHandler(), comet_callback]llm = OpenAI(temperature=0.9)synopsis_chain = LLMChain(llm=llm, prompt=prompt_template)test_prompts = [ { "article": """ The tower is 324 metres (1,063 ft) tall, about the same height as an 81-storey building, and the tallest structure in Paris. Its base is square, measuring 125 metres (410 ft) on each side. During its construction, the Eiffel Tower surpassed the Washington Monument to become the tallest man-made structure in the world, a title it held for 41 years until the Chrysler Building in New York City was finished in 1930. It was the first structure to reach a height of 300 metres. Due to the addition of a broadcasting aerial at the top of the tower in 1957, it is now taller than the Chrysler Building by 5.2 metres (17 ft). Excluding transmitters, the Eiffel Tower is the second tallest free-standing structure in France after the Millau Viaduct. """ }]print(synopsis_chain.apply(test_prompts, callbacks=callbacks))comet_callback.flush_tracker(synopsis_chain, finish=True) ``` ### Callback Tracer[​](#callback-tracer "Direct link to Callback Tracer") There is another integration with Comet: See an [example](https://python.langchain.com/docs/integrations/callbacks/comet_tracing/). ``` from langchain.callbacks.tracers.comet import CometTracer ```

Comet Comet machine learning platform integrates with your existing infrastructure and tools so you can manage, visualize, and optimize models—from training runs to production monitoring In this guide we will demonstrate how to track your Langchain Experiments, Evaluation Metrics, and LLM Sessions with Comet. Example Project: Comet with LangChain Install Comet and Dependencies​ %pip install --upgrade --quiet comet_ml langchain langchain-openai google-search-results spacy textstat pandas !{sys.executable} -m spacy download en_core_web_sm Initialize Comet and Set your Credentials​ You can grab your Comet API Key here or click the link after initializing Comet import comet_ml comet_ml.init(project_name="comet-example-langchain") Set OpenAI and SerpAPI credentials​ You will need an OpenAI API Key and a SerpAPI API Key to run the following examples import os os.environ["OPENAI_API_KEY"] = "..." # os.environ["OPENAI_ORGANIZATION"] = "..." os.environ["SERPAPI_API_KEY"] = "..." Scenario 1: Using just an LLM​ from langchain.callbacks import CometCallbackHandler, StdOutCallbackHandler from langchain_openai import OpenAI comet_callback = CometCallbackHandler( project_name="comet-example-langchain", complexity_metrics=True, stream_logs=True, tags=["llm"], visualizations=["dep"], ) callbacks = [StdOutCallbackHandler(), comet_callback] llm = OpenAI(temperature=0.9, callbacks=callbacks, verbose=True) llm_result = llm.generate(["Tell me a joke", "Tell me a poem", "Tell me a fact"] * 3) print("LLM result", llm_result) comet_callback.flush_tracker(llm, finish=True) Scenario 2: Using an LLM in a Chain​ from langchain.callbacks import CometCallbackHandler, StdOutCallbackHandler from langchain.chains import LLMChain from langchain_core.prompts import PromptTemplate from langchain_openai import OpenAI comet_callback = CometCallbackHandler( complexity_metrics=True, project_name="comet-example-langchain", stream_logs=True, tags=["synopsis-chain"], ) callbacks = [StdOutCallbackHandler(), comet_callback] llm = OpenAI(temperature=0.9, callbacks=callbacks) 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:""" prompt_template = PromptTemplate(input_variables=["title"], template=template) synopsis_chain = LLMChain(llm=llm, prompt=prompt_template, callbacks=callbacks) test_prompts = [{"title": "Documentary about Bigfoot in Paris"}] print(synopsis_chain.apply(test_prompts)) comet_callback.flush_tracker(synopsis_chain, finish=True) Scenario 3: Using An Agent with Tools​ from langchain.agents import initialize_agent, load_tools from langchain.callbacks import CometCallbackHandler, StdOutCallbackHandler from langchain_openai import OpenAI comet_callback = CometCallbackHandler( project_name="comet-example-langchain", complexity_metrics=True, stream_logs=True, tags=["agent"], ) callbacks = [StdOutCallbackHandler(), comet_callback] llm = OpenAI(temperature=0.9, callbacks=callbacks) tools = load_tools(["serpapi", "llm-math"], llm=llm, callbacks=callbacks) agent = initialize_agent( tools, llm, agent="zero-shot-react-description", callbacks=callbacks, verbose=True, ) agent.run( "Who is Leo DiCaprio's girlfriend? What is her current age raised to the 0.43 power?" ) comet_callback.flush_tracker(agent, finish=True) Scenario 4: Using Custom Evaluation Metrics​ The CometCallbackManager also allows you to define and use Custom Evaluation Metrics to assess generated outputs from your model. Let’s take a look at how this works. In the snippet below, we will use the ROUGE metric to evaluate the quality of a generated summary of an input prompt. %pip install --upgrade --quiet rouge-score from langchain.callbacks import CometCallbackHandler, StdOutCallbackHandler from langchain.chains import LLMChain from langchain_core.prompts import PromptTemplate from langchain_openai import OpenAI from rouge_score import rouge_scorer class Rouge: def __init__(self, reference): self.reference = reference self.scorer = rouge_scorer.RougeScorer(["rougeLsum"], use_stemmer=True) def compute_metric(self, generation, prompt_idx, gen_idx): prediction = generation.text results = self.scorer.score(target=self.reference, prediction=prediction) return { "rougeLsum_score": results["rougeLsum"].fmeasure, "reference": self.reference, } reference = """ The tower is 324 metres (1,063 ft) tall, about the same height as an 81-storey building. It was the first structure to reach a height of 300 metres. It is now taller than the Chrysler Building in New York City by 5.2 metres (17 ft) Excluding transmitters, the Eiffel Tower is the second tallest free-standing structure in France . """ rouge_score = Rouge(reference=reference) template = """Given the following article, it is your job to write a summary. Article: {article} Summary: This is the summary for the above article:""" prompt_template = PromptTemplate(input_variables=["article"], template=template) comet_callback = CometCallbackHandler( project_name="comet-example-langchain", complexity_metrics=False, stream_logs=True, tags=["custom_metrics"], custom_metrics=rouge_score.compute_metric, ) callbacks = [StdOutCallbackHandler(), comet_callback] llm = OpenAI(temperature=0.9) synopsis_chain = LLMChain(llm=llm, prompt=prompt_template) test_prompts = [ { "article": """ The tower is 324 metres (1,063 ft) tall, about the same height as an 81-storey building, and the tallest structure in Paris. Its base is square, measuring 125 metres (410 ft) on each side. During its construction, the Eiffel Tower surpassed the Washington Monument to become the tallest man-made structure in the world, a title it held for 41 years until the Chrysler Building in New York City was finished in 1930. It was the first structure to reach a height of 300 metres. Due to the addition of a broadcasting aerial at the top of the tower in 1957, it is now taller than the Chrysler Building by 5.2 metres (17 ft). Excluding transmitters, the Eiffel Tower is the second tallest free-standing structure in France after the Millau Viaduct. """ } ] print(synopsis_chain.apply(test_prompts, callbacks=callbacks)) comet_callback.flush_tracker(synopsis_chain, finish=True) Callback Tracer​ There is another integration with Comet: See an example. from langchain.callbacks.tracers.comet import CometTracer

https://python.langchain.com/docs/integrations/providers/couchbase/

[Couchbase](http://couchbase.com/) is an award-winning distributed NoSQL cloud database that delivers unmatched versatility, performance, scalability, and financial value for all of your cloud, mobile, AI, and edge computing applications. We have to install the `couchbase`package. ``` from langchain_community.document_loaders.couchbase import CouchbaseLoader ```

Couchbase is an award-winning distributed NoSQL cloud database that delivers unmatched versatility, performance, scalability, and financial value for all of your cloud, mobile, AI, and edge computing applications. We have to install the couchbasepackage. from langchain_community.document_loaders.couchbase import CouchbaseLoader

https://python.langchain.com/docs/integrations/providers/confluence/

## Confluence > [Confluence](https://www.atlassian.com/software/confluence) is a wiki collaboration platform that saves and organizes all of the project-related material. `Confluence` is a knowledge base that primarily handles content management activities. ## Installation and Setup[​](#installation-and-setup "Direct link to Installation and Setup") ``` pip install atlassian-python-api ``` We need to set up `username/api_key` or `Oauth2 login`. See [instructions](https://support.atlassian.com/atlassian-account/docs/manage-api-tokens-for-your-atlassian-account/). ## Document Loader[​](#document-loader "Direct link to Document Loader") See a [usage example](https://python.langchain.com/docs/integrations/document_loaders/confluence/). ``` from langchain_community.document_loaders import ConfluenceLoader ``` * * * #### Help us out by providing feedback on this documentation page:

Confluence Confluence is a wiki collaboration platform that saves and organizes all of the project-related material. Confluence is a knowledge base that primarily handles content management activities. Installation and Setup​ pip install atlassian-python-api We need to set up username/api_key or Oauth2 login. See instructions. Document Loader​ See a usage example. from langchain_community.document_loaders import ConfluenceLoader Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/ctransformers/

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

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

https://python.langchain.com/docs/integrations/providers/ctranslate2/

[CTranslate2](https://opennmt.net/CTranslate2/quickstart.html) is a C++ and Python library for efficient inference with Transformer models. The project implements a custom runtime that applies many performance optimization techniques such as weights quantization, layers fusion, batch reordering, etc., to accelerate and reduce the memory usage of Transformer models on CPU and GPU. A full list of features and supported models is included in the [project’s repository](https://opennmt.net/CTranslate2/guides/transformers.html). To start, please check out the official [quickstart guide](https://opennmt.net/CTranslate2/quickstart.html). ``` from langchain_community.llms import CTranslate2 ```

CTranslate2 is a C++ and Python library for efficient inference with Transformer models. The project implements a custom runtime that applies many performance optimization techniques such as weights quantization, layers fusion, batch reordering, etc., to accelerate and reduce the memory usage of Transformer models on CPU and GPU. A full list of features and supported models is included in the project’s repository. To start, please check out the official quickstart guide. from langchain_community.llms import CTranslate2

https://python.langchain.com/docs/integrations/providers/dashvector/

This document demonstrates to leverage DashVector within the LangChain ecosystem. In particular, it shows how to install DashVector, and how to use it as a VectorStore plugin in LangChain. It is broken into two parts: installation and setup, and then references to specific DashVector wrappers. A DashVector Collection is wrapped as a familiar VectorStore for native usage within LangChain, which allows it to be readily used for various scenarios, such as semantic search or example selection. ``` from langchain_community.vectorstores import DashVector ``` For a detailed walkthrough of the DashVector wrapper, please refer to [this notebook](https://python.langchain.com/docs/integrations/vectorstores/dashvector/)

This document demonstrates to leverage DashVector within the LangChain ecosystem. In particular, it shows how to install DashVector, and how to use it as a VectorStore plugin in LangChain. It is broken into two parts: installation and setup, and then references to specific DashVector wrappers. A DashVector Collection is wrapped as a familiar VectorStore for native usage within LangChain, which allows it to be readily used for various scenarios, such as semantic search or example selection. from langchain_community.vectorstores import DashVector For a detailed walkthrough of the DashVector wrapper, please refer to this notebook

https://python.langchain.com/docs/integrations/providers/cube/

We have to get the API key and the URL of the Cube instance. See [these instructions](https://cube.dev/docs/product/apis-integrations/rest-api#configuration-base-path). ``` from langchain_community.document_loaders import CubeSemanticLoader ```

We have to get the API key and the URL of the Cube instance. See these instructions. from langchain_community.document_loaders import CubeSemanticLoader

https://python.langchain.com/docs/integrations/providers/datadog/

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

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

https://python.langchain.com/docs/integrations/providers/databricks/

## Databricks The [Databricks](https://www.databricks.com/) Lakehouse Platform unifies data, analytics, and AI on one platform. Databricks embraces the LangChain ecosystem in various ways: 1. Databricks connector for the SQLDatabase Chain: SQLDatabase.from\_databricks() provides an easy way to query your data on Databricks through LangChain 2. Databricks MLflow integrates with LangChain: Tracking and serving LangChain applications with fewer steps 3. Databricks as an LLM provider: Deploy your fine-tuned LLMs on Databricks via serving endpoints or cluster driver proxy apps, and query it as langchain.llms.Databricks 4. Databricks Dolly: Databricks open-sourced Dolly which allows for commercial use, and can be accessed through the Hugging Face Hub ## Databricks connector for the SQLDatabase Chain[​](#databricks-connector-for-the-sqldatabase-chain "Direct link to Databricks connector for the SQLDatabase Chain") You can connect to [Databricks runtimes](https://docs.databricks.com/runtime/index.html) and [Databricks SQL](https://www.databricks.com/product/databricks-sql) using the SQLDatabase wrapper of LangChain. ## Databricks MLflow integrates with LangChain[​](#databricks-mlflow-integrates-with-langchain "Direct link to Databricks MLflow integrates with LangChain") MLflow is an open-source platform to manage the ML lifecycle, including experimentation, reproducibility, deployment, and a central model registry. See the notebook [MLflow Callback Handler](https://python.langchain.com/docs/integrations/providers/mlflow_tracking/) for details about MLflow's integration with LangChain. Databricks provides a fully managed and hosted version of MLflow integrated with enterprise security features, high availability, and other Databricks workspace features such as experiment and run management and notebook revision capture. MLflow on Databricks offers an integrated experience for tracking and securing machine learning model training runs and running machine learning projects. See [MLflow guide](https://docs.databricks.com/mlflow/index.html) for more details. Databricks MLflow makes it more convenient to develop LangChain applications on Databricks. For MLflow tracking, you don't need to set the tracking uri. For MLflow Model Serving, you can save LangChain Chains in the MLflow langchain flavor, and then register and serve the Chain with a few clicks on Databricks, with credentials securely managed by MLflow Model Serving. ## Databricks External Models[​](#databricks-external-models "Direct link to Databricks External Models") [Databricks External Models](https://docs.databricks.com/generative-ai/external-models/index.html) is a service that is 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. The following example creates an endpoint that serves OpenAI's GPT-4 model and generates a chat response from it: ``` from langchain_community.chat_models import ChatDatabricksfrom langchain_core.messages import HumanMessagefrom mlflow.deployments import get_deploy_clientclient = get_deploy_client("databricks")name = f"chat"client.create_endpoint( name=name, config={ "served_entities": [ { "name": "test", "external_model": { "name": "gpt-4", "provider": "openai", "task": "llm/v1/chat", "openai_config": { "openai_api_key": "{{secrets/<scope>/<key>}}", }, }, } ], },)chat = ChatDatabricks(endpoint=name, temperature=0.1)print(chat([HumanMessage(content="hello")]))# -> content='Hello! How can I assist you today?' ``` ## Databricks Foundation Model APIs[​](#databricks-foundation-model-apis "Direct link to Databricks Foundation Model APIs") [Databricks Foundation Model APIs](https://docs.databricks.com/machine-learning/foundation-models/index.html) allow you to access and query state-of-the-art open source models from dedicated serving endpoints. With Foundation Model APIs, developers can quickly and easily build applications that leverage a high-quality generative AI model without maintaining their own model deployment. The following example uses the `databricks-bge-large-en` endpoint to generate embeddings from text: ``` from langchain_community.embeddings import DatabricksEmbeddingsembeddings = DatabricksEmbeddings(endpoint="databricks-bge-large-en")print(embeddings.embed_query("hello")[:3])# -> [0.051055908203125, 0.007221221923828125, 0.003879547119140625, ...] ``` ## Databricks as an LLM provider[​](#databricks-as-an-llm-provider "Direct link to Databricks as an LLM provider") The notebook [Wrap Databricks endpoints as LLMs](https://python.langchain.com/docs/integrations/llms/databricks/#wrapping-a-serving-endpoint-custom-model) demonstrates how to serve a custom model that has been registered by MLflow as a Databricks endpoint. It supports two types of endpoints: the serving endpoint, which is recommended for both production and development, and the cluster driver proxy app, which is recommended for interactive development. ## Databricks Vector Search[​](#databricks-vector-search "Direct link to Databricks Vector Search") Databricks Vector Search is a serverless similarity search engine that allows you to store a vector representation of your data, including metadata, in a vector database. With Vector Search, you can create auto-updating vector search indexes from Delta tables managed by Unity Catalog and query them with a simple API to return the most similar vectors. See the notebook [Databricks Vector Search](https://python.langchain.com/docs/integrations/vectorstores/databricks_vector_search/) for instructions to use it with LangChain.

Databricks The Databricks Lakehouse Platform unifies data, analytics, and AI on one platform. Databricks embraces the LangChain ecosystem in various ways: Databricks connector for the SQLDatabase Chain: SQLDatabase.from_databricks() provides an easy way to query your data on Databricks through LangChain Databricks MLflow integrates with LangChain: Tracking and serving LangChain applications with fewer steps Databricks as an LLM provider: Deploy your fine-tuned LLMs on Databricks via serving endpoints or cluster driver proxy apps, and query it as langchain.llms.Databricks Databricks Dolly: Databricks open-sourced Dolly which allows for commercial use, and can be accessed through the Hugging Face Hub Databricks connector for the SQLDatabase Chain​ You can connect to Databricks runtimes and Databricks SQL using the SQLDatabase wrapper of LangChain. Databricks MLflow integrates with LangChain​ MLflow is an open-source platform to manage the ML lifecycle, including experimentation, reproducibility, deployment, and a central model registry. See the notebook MLflow Callback Handler for details about MLflow's integration with LangChain. Databricks provides a fully managed and hosted version of MLflow integrated with enterprise security features, high availability, and other Databricks workspace features such as experiment and run management and notebook revision capture. MLflow on Databricks offers an integrated experience for tracking and securing machine learning model training runs and running machine learning projects. See MLflow guide for more details. Databricks MLflow makes it more convenient to develop LangChain applications on Databricks. For MLflow tracking, you don't need to set the tracking uri. For MLflow Model Serving, you can save LangChain Chains in the MLflow langchain flavor, and then register and serve the Chain with a few clicks on Databricks, with credentials securely managed by MLflow Model Serving. Databricks External Models​ Databricks External Models is a service that is 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. The following example creates an endpoint that serves OpenAI's GPT-4 model and generates a chat response from it: from langchain_community.chat_models import ChatDatabricks from langchain_core.messages import HumanMessage from mlflow.deployments import get_deploy_client client = get_deploy_client("databricks") name = f"chat" client.create_endpoint( name=name, config={ "served_entities": [ { "name": "test", "external_model": { "name": "gpt-4", "provider": "openai", "task": "llm/v1/chat", "openai_config": { "openai_api_key": "{{secrets/<scope>/<key>}}", }, }, } ], }, ) chat = ChatDatabricks(endpoint=name, temperature=0.1) print(chat([HumanMessage(content="hello")])) # -> content='Hello! How can I assist you today?' Databricks Foundation Model APIs​ Databricks Foundation Model APIs allow you to access and query state-of-the-art open source models from dedicated serving endpoints. With Foundation Model APIs, developers can quickly and easily build applications that leverage a high-quality generative AI model without maintaining their own model deployment. The following example uses the databricks-bge-large-en endpoint to generate embeddings from text: from langchain_community.embeddings import DatabricksEmbeddings embeddings = DatabricksEmbeddings(endpoint="databricks-bge-large-en") print(embeddings.embed_query("hello")[:3]) # -> [0.051055908203125, 0.007221221923828125, 0.003879547119140625, ...] Databricks as an LLM provider​ The notebook Wrap Databricks endpoints as LLMs demonstrates how to serve a custom model that has been registered by MLflow as a Databricks endpoint. It supports two types of endpoints: the serving endpoint, which is recommended for both production and development, and the cluster driver proxy app, which is recommended for interactive development. Databricks Vector Search​ Databricks Vector Search is a serverless similarity search engine that allows you to store a vector representation of your data, including metadata, in a vector database. With Vector Search, you can create auto-updating vector search indexes from Delta tables managed by Unity Catalog and query them with a simple API to return the most similar vectors. See the notebook Databricks Vector Search for instructions to use it with LangChain.

https://python.langchain.com/docs/integrations/providers/dataforseo/

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

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

https://python.langchain.com/docs/integrations/providers/arangodb/

[ArangoDB](https://github.com/arangodb/arangodb) is a scalable graph database system to drive value from connected data, faster. Native graphs, an integrated search engine, and JSON support, via a single query language. ArangoDB runs on-prem, in the cloud – anywhere. Connect your `ArangoDB` Database with a chat model to get insights on your data. ``` from arango import ArangoClientfrom langchain_community.graphs import ArangoGraphfrom langchain.chains import ArangoGraphQAChain ```

ArangoDB is a scalable graph database system to drive value from connected data, faster. Native graphs, an integrated search engine, and JSON support, via a single query language. ArangoDB runs on-prem, in the cloud – anywhere. Connect your ArangoDB Database with a chat model to get insights on your data. from arango import ArangoClient from langchain_community.graphs import ArangoGraph from langchain.chains import ArangoGraphQAChain

https://python.langchain.com/docs/integrations/providers/datadog_logs/

``` pip install datadog_api_client ``` We must initialize the loader with the Datadog API key and APP key, and we need to set up the query to extract the desired logs.

pip install datadog_api_client We must initialize the loader with the Datadog API key and APP key, and we need to set up the query to extract the desired logs.

https://python.langchain.com/docs/integrations/providers/arthur_tracking/

The following guide shows how to run a registered chat LLM with the Arthur callback handler to automatically log model inferences to Arthur. ``` def make_langchain_chat_llm(): return ChatOpenAI( streaming=True, temperature=0.1, callbacks=[ StreamingStdOutCallbackHandler(), ArthurCallbackHandler.from_credentials( arthur_model_id, arthur_url=arthur_url, arthur_login=arthur_login ), ], ) ``` ``` Please enter password for admin: ········ ``` Running the chat LLM with this `run` function will save the chat history in an ongoing list so that the conversation can reference earlier messages and log each response to the Arthur platform. You can view the history of this model’s inferences on your [model dashboard page](https://app.arthur.ai/). ``` >>> input >>>>>>: What is a callback handler?A callback handler, also known as a callback function or callback method, is a piece of code that is executed in response to a specific event or condition. It is commonly used in programming languages that support event-driven or asynchronous programming paradigms.The purpose of a callback handler is to provide a way for developers to define custom behavior that should be executed when a certain event occurs. Instead of waiting for a result or blocking the execution, the program registers a callback function and continues with other tasks. When the event is triggered, the callback function is invoked, allowing the program to respond accordingly.Callback handlers are commonly used in various scenarios, such as handling user input, responding to network requests, processing asynchronous operations, and implementing event-driven architectures. They provide a flexible and modular way to handle events and decouple different components of a system.>>> input >>>>>>: What do I need to do to get the full benefits of thisTo get the full benefits of using a callback handler, you should consider the following:1. Understand the event or condition: Identify the specific event or condition that you want to respond to with a callback handler. This could be user input, network requests, or any other asynchronous operation.2. Define the callback function: Create a function that will be executed when the event or condition occurs. This function should contain the desired behavior or actions you want to take in response to the event.3. Register the callback function: Depending on the programming language or framework you are using, you may need to register or attach the callback function to the appropriate event or condition. This ensures that the callback function is invoked when the event occurs.4. Handle the callback: Implement the necessary logic within the callback function to handle the event or condition. This could involve updating the user interface, processing data, making further requests, or triggering other actions.5. Consider error handling: It's important to handle any potential errors or exceptions that may occur within the callback function. This ensures that your program can gracefully handle unexpected situations and prevent crashes or undesired behavior.6. Maintain code readability and modularity: As your codebase grows, it's crucial to keep your callback handlers organized and maintainable. Consider using design patterns or architectural principles to structure your code in a modular and scalable way.By following these steps, you can leverage the benefits of callback handlers, such as asynchronous and event-driven programming, improved responsiveness, and modular code design.>>> input >>>>>>: q ```

The following guide shows how to run a registered chat LLM with the Arthur callback handler to automatically log model inferences to Arthur. def make_langchain_chat_llm(): return ChatOpenAI( streaming=True, temperature=0.1, callbacks=[ StreamingStdOutCallbackHandler(), ArthurCallbackHandler.from_credentials( arthur_model_id, arthur_url=arthur_url, arthur_login=arthur_login ), ], ) Please enter password for admin: ········ Running the chat LLM with this run function will save the chat history in an ongoing list so that the conversation can reference earlier messages and log each response to the Arthur platform. You can view the history of this model’s inferences on your model dashboard page. >>> input >>> >>>: What is a callback handler? A callback handler, also known as a callback function or callback method, is a piece of code that is executed in response to a specific event or condition. It is commonly used in programming languages that support event-driven or asynchronous programming paradigms. The purpose of a callback handler is to provide a way for developers to define custom behavior that should be executed when a certain event occurs. Instead of waiting for a result or blocking the execution, the program registers a callback function and continues with other tasks. When the event is triggered, the callback function is invoked, allowing the program to respond accordingly. Callback handlers are commonly used in various scenarios, such as handling user input, responding to network requests, processing asynchronous operations, and implementing event-driven architectures. They provide a flexible and modular way to handle events and decouple different components of a system. >>> input >>> >>>: What do I need to do to get the full benefits of this To get the full benefits of using a callback handler, you should consider the following: 1. Understand the event or condition: Identify the specific event or condition that you want to respond to with a callback handler. This could be user input, network requests, or any other asynchronous operation. 2. Define the callback function: Create a function that will be executed when the event or condition occurs. This function should contain the desired behavior or actions you want to take in response to the event. 3. Register the callback function: Depending on the programming language or framework you are using, you may need to register or attach the callback function to the appropriate event or condition. This ensures that the callback function is invoked when the event occurs. 4. Handle the callback: Implement the necessary logic within the callback function to handle the event or condition. This could involve updating the user interface, processing data, making further requests, or triggering other actions. 5. Consider error handling: It's important to handle any potential errors or exceptions that may occur within the callback function. This ensures that your program can gracefully handle unexpected situations and prevent crashes or undesired behavior. 6. Maintain code readability and modularity: As your codebase grows, it's crucial to keep your callback handlers organized and maintainable. Consider using design patterns or architectural principles to structure your code in a modular and scalable way. By following these steps, you can leverage the benefits of callback handlers, such as asynchronous and event-driven programming, improved responsiveness, and modular code design. >>> input >>> >>>: q

https://python.langchain.com/docs/integrations/providers/argilla/

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

Argilla Argilla is an open-source data curation platform for LLMs. Using Argilla, everyone can build robust language models through faster data curation using both human and machine feedback. Argilla provides support for each step in the MLOps cycle, from data labeling to model monitoring. Installation and Setup​ Get your API key. Install the Python package: Callbacks​ from langchain.callbacks import ArgillaCallbackHandler See an example.

https://python.langchain.com/docs/integrations/providers/arcee/

[Arcee](https://www.arcee.ai/about/about-us) enables the development and advancement of what we coin as SLMs—small, specialized, secure, and scalable language models. By offering a SLM Adaptation System and a seamless, secure integration, `Arcee` empowers enterprises to harness the full potential of domain-adapted language models, driving the transformative innovation in operations. Get your `Arcee API` key. ``` from langchain_community.llms import Arcee ```

Arcee enables the development and advancement of what we coin as SLMs—small, specialized, secure, and scalable language models. By offering a SLM Adaptation System and a seamless, secure integration, Arcee empowers enterprises to harness the full potential of domain-adapted language models, driving the transformative innovation in operations. Get your Arcee API key. from langchain_community.llms import Arcee

https://python.langchain.com/docs/integrations/providers/arcgis/

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

ArcGIS is a family of client, server and online geographic information system software developed and maintained by Esri. ArcGISLoader uses the arcgis package. arcgis is a Python library for the vector and raster analysis, geocoding, map making, routing and directions. It administers, organizes and manages users, groups and information items in your GIS. It enables access to ready-to-use maps and curated geographic data from Esri and other authoritative sources, and works with your own data as well. We have to install the arcgis package. from langchain_community.document_loaders import ArcGISLoader

https://python.langchain.com/docs/integrations/providers/arxiv/

[arXiv](https://arxiv.org/) is an open-access archive for 2 million scholarly articles in the fields of physics, mathematics, computer science, quantitative biology, quantitative finance, statistics, electrical engineering and systems science, and economics. First, you need to install `arxiv` python package. Second, you need to install `PyMuPDF` python package which transforms PDF files downloaded from the `arxiv.org` site into the text format. ``` from langchain_community.document_loaders import ArxivLoader ```

arXiv is an open-access archive for 2 million scholarly articles in the fields of physics, mathematics, computer science, quantitative biology, quantitative finance, statistics, electrical engineering and systems science, and economics. First, you need to install arxiv python package. Second, you need to install PyMuPDF python package which transforms PDF files downloaded from the arxiv.org site into the text format. from langchain_community.document_loaders import ArxivLoader

https://python.langchain.com/docs/integrations/providers/awadb/

## AwaDB > [AwaDB](https://github.com/awa-ai/awadb) is an AI Native database for the search and storage of embedding vectors used by LLM Applications. ## Installation and Setup[​](#installation-and-setup "Direct link to Installation and Setup") ## Vector store[​](#vector-store "Direct link to Vector store") ``` from langchain_community.vectorstores import AwaDB ``` See a [usage example](https://python.langchain.com/docs/integrations/vectorstores/awadb/). ## Embedding models[​](#embedding-models "Direct link to Embedding models") ``` from langchain_community.embeddings import AwaEmbeddings ``` See a [usage example](https://python.langchain.com/docs/integrations/text_embedding/awadb/). * * * #### Help us out by providing feedback on this documentation page:

AwaDB AwaDB is an AI Native database for the search and storage of embedding vectors used by LLM Applications. Installation and Setup​ Vector store​ from langchain_community.vectorstores import AwaDB See a usage example. Embedding models​ from langchain_community.embeddings import AwaEmbeddings See a usage example. Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/atlas/

## Atlas > [Nomic Atlas](https://docs.nomic.ai/index.html) is a platform for interacting with both small and internet scale unstructured datasets. ## Installation and Setup[​](#installation-and-setup "Direct link to Installation and Setup") * Install the Python package with `pip install nomic` * `Nomic` is also included in langchains poetry extras `poetry install -E all` ## VectorStore[​](#vectorstore "Direct link to VectorStore") See a [usage example](https://python.langchain.com/docs/integrations/vectorstores/atlas/). ``` from langchain_community.vectorstores import AtlasDB ``` * * * #### Help us out by providing feedback on this documentation page:

Atlas Nomic Atlas is a platform for interacting with both small and internet scale unstructured datasets. Installation and Setup​ Install the Python package with pip install nomic Nomic is also included in langchains poetry extras poetry install -E all VectorStore​ See a usage example. from langchain_community.vectorstores import AtlasDB Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/azlyrics/

There isn't any special setup for it. ``` from langchain_community.document_loaders import AZLyricsLoader ```

There isn't any special setup for it. from langchain_community.document_loaders import AZLyricsLoader

https://python.langchain.com/docs/integrations/providers/astradb/

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

Astra DB DataStax Astra DB is a serverless vector-capable database built on Apache Cassandra®and made conveniently available through an easy-to-use JSON API. See a tutorial provided by DataStax. Installation and Setup​ Install the following Python package: pip install "langchain-astradb>=0.1.0" Get the connection secrets. Set up the following environment variables: ASTRA_DB_APPLICATION_TOKEN="TOKEN" ASTRA_DB_API_ENDPOINT="API_ENDPOINT" Vector Store​ from langchain_astradb import AstraDBVectorStore vector_store = AstraDBVectorStore( embedding=my_embedding, collection_name="my_store", api_endpoint=ASTRA_DB_API_ENDPOINT, token=ASTRA_DB_APPLICATION_TOKEN, ) Learn more in the example notebook. See the example provided by DataStax. Chat message history​ from langchain_astradb import AstraDBChatMessageHistory message_history = AstraDBChatMessageHistory( session_id="test-session", api_endpoint=ASTRA_DB_API_ENDPOINT, token=ASTRA_DB_APPLICATION_TOKEN, ) See the usage example. LLM Cache​ from langchain.globals import set_llm_cache from langchain_astradb import AstraDBCache set_llm_cache(AstraDBCache( api_endpoint=ASTRA_DB_API_ENDPOINT, token=ASTRA_DB_APPLICATION_TOKEN, )) Learn more in the example notebook (scroll to the Astra DB section). Semantic LLM Cache​ from langchain.globals import set_llm_cache from langchain_astradb import AstraDBSemanticCache set_llm_cache(AstraDBSemanticCache( embedding=my_embedding, api_endpoint=ASTRA_DB_API_ENDPOINT, token=ASTRA_DB_APPLICATION_TOKEN, )) Learn more in the example notebook (scroll to the appropriate section). Learn more in the example notebook. Document loader​ from langchain_astradb import AstraDBLoader loader = AstraDBLoader( collection_name="my_collection", api_endpoint=ASTRA_DB_API_ENDPOINT, token=ASTRA_DB_APPLICATION_TOKEN, ) Learn more in the example notebook. Self-querying retriever​ from langchain_astradb import AstraDBVectorStore from langchain.retrievers.self_query.base import SelfQueryRetriever vector_store = AstraDBVectorStore( embedding=my_embedding, collection_name="my_store", api_endpoint=ASTRA_DB_API_ENDPOINT, token=ASTRA_DB_APPLICATION_TOKEN, ) retriever = SelfQueryRetriever.from_llm( my_llm, vector_store, document_content_description, metadata_field_info ) Learn more in the example notebook. Store​ from langchain_astradb import AstraDBStore store = AstraDBStore( collection_name="my_kv_store", api_endpoint=ASTRA_DB_API_ENDPOINT, token=ASTRA_DB_APPLICATION_TOKEN, ) Learn more in the example notebook. Byte Store​ from langchain_astradb import AstraDBByteStore store = AstraDBByteStore( collection_name="my_kv_store", api_endpoint=ASTRA_DB_API_ENDPOINT, token=ASTRA_DB_APPLICATION_TOKEN, ) Learn more in the example notebook.

https://python.langchain.com/docs/integrations/providers/assemblyai/

[AssemblyAI](https://www.assemblyai.com/) builds `Speech AI` models for tasks like speech-to-text, speaker diarization, speech summarization, and more. `AssemblyAI’s` Speech AI models include accurate speech-to-text for voice data (such as calls, virtual meetings, and podcasts), speaker detection, sentiment analysis, chapter detection, PII redaction. Install the `assemblyai` package. ``` pip install -U assemblyai ``` The `AssemblyAIAudioTranscriptLoader` transcribes audio files with the `AssemblyAI API` and loads the transcribed text into documents.

AssemblyAI builds Speech AI models for tasks like speech-to-text, speaker diarization, speech summarization, and more. AssemblyAI’s Speech AI models include accurate speech-to-text for voice data (such as calls, virtual meetings, and podcasts), speaker detection, sentiment analysis, chapter detection, PII redaction. Install the assemblyai package. pip install -U assemblyai The AssemblyAIAudioTranscriptLoader transcribes audio files with the AssemblyAI API and loads the transcribed text into documents.

https://python.langchain.com/docs/integrations/providers/bageldb/

[BagelDB](https://www.bageldb.ai/) (`Open Vector Database for AI`), is like GitHub for AI data. It is a collaborative platform where users can create, share, and manage vector datasets. It can support private projects for independent developers, internal collaborations for enterprises, and public contributions for data DAOs. ``` from langchain_community.vectorstores import Bagel ```

BagelDB (Open Vector Database for AI), is like GitHub for AI data. It is a collaborative platform where users can create, share, and manage vector datasets. It can support private projects for independent developers, internal collaborations for enterprises, and public contributions for data DAOs. from langchain_community.vectorstores import Bagel

https://python.langchain.com/docs/integrations/providers/baidu/

## Baidu > [Baidu Cloud](https://cloud.baidu.com/) is a cloud service provided by `Baidu, Inc.`, headquartered in Beijing. It offers a cloud storage service, client software, file management, resource sharing, and Third Party Integration. ## Installation and Setup[​](#installation-and-setup "Direct link to Installation and Setup") Register and get the `Qianfan` `AK` and `SK` keys [here](https://cloud.baidu.com/product/wenxinworkshop). ## LLMs[​](#llms "Direct link to LLMs") ### Baidu Qianfan[​](#baidu-qianfan "Direct link to Baidu Qianfan") See a [usage example](https://python.langchain.com/docs/integrations/llms/baidu_qianfan_endpoint/). ``` from langchain_community.llms import QianfanLLMEndpoint ``` ## Chat models[​](#chat-models "Direct link to Chat models") ### Qianfan Chat Endpoint[​](#qianfan-chat-endpoint "Direct link to Qianfan Chat Endpoint") See a [usage example](https://python.langchain.com/docs/integrations/chat/baidu_qianfan_endpoint/). ``` from langchain_community.chat_models import QianfanChatEndpoint ``` ## Embedding models[​](#embedding-models "Direct link to Embedding models") ### Baidu Qianfan[​](#baidu-qianfan-1 "Direct link to Baidu Qianfan") See a [usage example](https://python.langchain.com/docs/integrations/text_embedding/baidu_qianfan_endpoint/). ``` from langchain_community.embeddings import QianfanEmbeddingsEndpoint ``` ## Vector stores[​](#vector-stores "Direct link to Vector stores") ### Baidu Cloud ElasticSearch VectorSearch[​](#baidu-cloud-elasticsearch-vectorsearch "Direct link to Baidu Cloud ElasticSearch VectorSearch") See a [usage example](https://python.langchain.com/docs/integrations/vectorstores/baiducloud_vector_search/). ``` from langchain_community.vectorstores import BESVectorStore ``` * * * #### Help us out by providing feedback on this documentation page:

Baidu Baidu Cloud is a cloud service provided by Baidu, Inc., headquartered in Beijing. It offers a cloud storage service, client software, file management, resource sharing, and Third Party Integration. Installation and Setup​ Register and get the Qianfan AK and SK keys here. LLMs​ Baidu Qianfan​ See a usage example. from langchain_community.llms import QianfanLLMEndpoint Chat models​ Qianfan Chat Endpoint​ See a usage example. from langchain_community.chat_models import QianfanChatEndpoint Embedding models​ Baidu Qianfan​ See a usage example. from langchain_community.embeddings import QianfanEmbeddingsEndpoint Vector stores​ Baidu Cloud ElasticSearch VectorSearch​ See a usage example. from langchain_community.vectorstores import BESVectorStore Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/bananadev/

You'll need to set up a Github repo for your Banana app. You can get started in 5 minutes using [this guide](https://docs.banana.dev/banana-docs/). Alternatively, for a ready-to-go LLM example, you can check out Banana's [CodeLlama-7B-Instruct-GPTQ](https://github.com/bananaml/demo-codellama-7b-instruct-gptq) GitHub repository. Just fork it and deploy it within Banana. To use Banana apps within Langchain, you must include the `outputs` key in the returned json, and the value must be a string. ``` @app.handler("/")def handler(context: dict, request: Request) -> Response: """Handle a request to generate code from a prompt.""" model = context.get("model") tokenizer = context.get("tokenizer") max_new_tokens = request.json.get("max_new_tokens", 512) temperature = request.json.get("temperature", 0.7) prompt = request.json.get("prompt") prompt_template=f'''[INST] Write code to solve the following coding problem that obeys the constraints and passes the example test cases. Please wrap your code answer using ```: {prompt} [/INST] ''' input_ids = tokenizer(prompt_template, return_tensors='pt').input_ids.cuda() output = model.generate(inputs=input_ids, temperature=temperature, max_new_tokens=max_new_tokens) result = tokenizer.decode(output[0]) return Response(json={"outputs": result}, status=200) ```

You'll need to set up a Github repo for your Banana app. You can get started in 5 minutes using this guide. Alternatively, for a ready-to-go LLM example, you can check out Banana's CodeLlama-7B-Instruct-GPTQ GitHub repository. Just fork it and deploy it within Banana. To use Banana apps within Langchain, you must include the outputs key in the returned json, and the value must be a string. @app.handler("/") def handler(context: dict, request: Request) -> Response: """Handle a request to generate code from a prompt.""" model = context.get("model") tokenizer = context.get("tokenizer") max_new_tokens = request.json.get("max_new_tokens", 512) temperature = request.json.get("temperature", 0.7) prompt = request.json.get("prompt") prompt_template=f'''[INST] Write code to solve the following coding problem that obeys the constraints and passes the example test cases. Please wrap your code answer using ```: {prompt} [/INST] ''' input_ids = tokenizer(prompt_template, return_tensors='pt').input_ids.cuda() output = model.generate(inputs=input_ids, temperature=temperature, max_new_tokens=max_new_tokens) result = tokenizer.decode(output[0]) return Response(json={"outputs": result}, status=200)

https://python.langchain.com/docs/integrations/providers/baseten/

Export your API key to your as an environment variable called `BASETEN_API_KEY`. ``` export BASETEN_API_KEY="paste_your_api_key_here" ```

Export your API key to your as an environment variable called BASETEN_API_KEY. export BASETEN_API_KEY="paste_your_api_key_here"

https://python.langchain.com/docs/integrations/providers/baichuan/

## Baichuan > [Baichuan Inc.](https://www.baichuan-ai.com/) is a Chinese startup in the era of AGI, dedicated to addressing fundamental human needs: Efficiency, Health, and Happiness. ## Installation and Setup[​](#installation-and-setup "Direct link to Installation and Setup") Register and get an API key [here](https://platform.baichuan-ai.com/). ## LLMs[​](#llms "Direct link to LLMs") See a [usage example](https://python.langchain.com/docs/integrations/llms/baichuan/). ``` from langchain_community.llms import BaichuanLLM ``` ## Chat models[​](#chat-models "Direct link to Chat models") See a [usage example](https://python.langchain.com/docs/integrations/chat/baichuan/). ``` from langchain_community.chat_models import ChatBaichuan ``` ## Embedding models[​](#embedding-models "Direct link to Embedding models") See a [usage example](https://python.langchain.com/docs/integrations/text_embedding/baichuan/). ``` from langchain_community.embeddings import BaichuanTextEmbeddings ``` * * * #### Help us out by providing feedback on this documentation page:

Baichuan Baichuan Inc. is a Chinese startup in the era of AGI, dedicated to addressing fundamental human needs: Efficiency, Health, and Happiness. Installation and Setup​ Register and get an API key here. LLMs​ See a usage example. from langchain_community.llms import BaichuanLLM Chat models​ See a usage example. from langchain_community.chat_models import ChatBaichuan Embedding models​ See a usage example. from langchain_community.embeddings import BaichuanTextEmbeddings Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/beautiful_soup/

[Beautiful Soup](https://www.crummy.com/software/BeautifulSoup/) is a Python package for parsing HTML and XML documents (including having malformed markup, i.e. non-closed tags, so named after tag soup). It creates a parse tree for parsed pages that can be used to extract data from HTML,\[3\] which is useful for web scraping.

Beautiful Soup is a Python package for parsing HTML and XML documents (including having malformed markup, i.e. non-closed tags, so named after tag soup). It creates a parse tree for parsed pages that can be used to extract data from HTML,[3] which is useful for web scraping.

https://python.langchain.com/docs/integrations/providers/bilibili/

## BiliBili > [Bilibili](https://www.bilibili.tv/) is one of the most beloved long-form video sites in China. ## Installation and Setup[​](#installation-and-setup "Direct link to Installation and Setup") ``` pip install bilibili-api-python ``` ## Document Loader[​](#document-loader "Direct link to Document Loader") See a [usage example](https://python.langchain.com/docs/integrations/document_loaders/bilibili/). ``` from langchain_community.document_loaders import BiliBiliLoader ``` * * * #### Help us out by providing feedback on this documentation page:

BiliBili Bilibili is one of the most beloved long-form video sites in China. Installation and Setup​ pip install bilibili-api-python Document Loader​ See a usage example. from langchain_community.document_loaders import BiliBiliLoader Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/bibtex/

## BibTeX > [BibTeX](https://www.ctan.org/pkg/bibtex) is a file format and reference management system commonly used in conjunction with `LaTeX` typesetting. It serves as a way to organize and store bibliographic information for academic and research documents. ## Installation and Setup[​](#installation-and-setup "Direct link to Installation and Setup") We have to install the `bibtexparser` and `pymupdf` packages. ``` pip install bibtexparser pymupdf ``` ## Document loader[​](#document-loader "Direct link to Document loader") See a [usage example](https://python.langchain.com/docs/integrations/document_loaders/bibtex/). ``` from langchain_community.document_loaders import BibtexLoader ``` * * * #### Help us out by providing feedback on this documentation page:

BibTeX BibTeX is a file format and reference management system commonly used in conjunction with LaTeX typesetting. It serves as a way to organize and store bibliographic information for academic and research documents. Installation and Setup​ We have to install the bibtexparser and pymupdf packages. pip install bibtexparser pymupdf Document loader​ See a usage example. from langchain_community.document_loaders import BibtexLoader Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/beam/

## Beam > [Beam](https://www.beam.cloud/) is a cloud computing platform that allows you to run your code on remote servers with GPUs. ## Installation and Setup[​](#installation-and-setup "Direct link to Installation and Setup") * [Create an account](https://www.beam.cloud/) * Install the Beam CLI with `curl https://raw.githubusercontent.com/slai-labs/get-beam/main/get-beam.sh -sSfL | sh` * Register API keys with `beam configure` * Set environment variables (`BEAM_CLIENT_ID`) and (`BEAM_CLIENT_SECRET`) * Install the Beam SDK: ## LLMs[​](#llms "Direct link to LLMs") See a [usage example](https://python.langchain.com/docs/integrations/llms/beam/). See another example in the [Beam documentation](https://docs.beam.cloud/examples/langchain). ``` from langchain_community.llms.beam import Beam ``` * * * #### Help us out by providing feedback on this documentation page:

Beam Beam is a cloud computing platform that allows you to run your code on remote servers with GPUs. Installation and Setup​ Create an account Install the Beam CLI with curl https://raw.githubusercontent.com/slai-labs/get-beam/main/get-beam.sh -sSfL | sh Register API keys with beam configure Set environment variables (BEAM_CLIENT_ID) and (BEAM_CLIENT_SECRET) Install the Beam SDK: LLMs​ See a usage example. See another example in the Beam documentation. from langchain_community.llms.beam import Beam Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/blackboard/

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

Blackboard Learn (previously the Blackboard Learning Management System) is a web-based virtual learning environment and learning management system developed by Blackboard Inc. The software features course management, customizable open architecture, and scalable design that allows integration with student information systems and authentication protocols. It may be installed on local servers, hosted by Blackboard ASP Solutions, or provided as Software as a Service hosted on Amazon Web Services. Its main purposes are stated to include the addition of online elements to courses traditionally delivered face-to-face and development of completely online courses with few or no face-to-face meetings. There isn't any special setup for it. from langchain_community.document_loaders import BlackboardLoader

https://python.langchain.com/docs/integrations/providers/bittensor/

## Bittensor > [Neural Internet Bittensor](https://neuralinternet.ai/) network, an open source protocol that powers a decentralized, blockchain-based, machine learning network. ## Installation and Setup[​](#installation-and-setup "Direct link to Installation and Setup") Get your API\_KEY from [Neural Internet](https://neuralinternet.ai/). ## LLMs[​](#llms "Direct link to LLMs") See a [usage example](https://python.langchain.com/docs/integrations/llms/bittensor/). ``` from langchain_community.llms import NIBittensorLLM ``` * * * #### Help us out by providing feedback on this documentation page:

Bittensor Neural Internet Bittensor network, an open source protocol that powers a decentralized, blockchain-based, machine learning network. Installation and Setup​ Get your API_KEY from Neural Internet. LLMs​ See a usage example. from langchain_community.llms import NIBittensorLLM Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/breebs/

[Breebs](https://www.breebs.com/) is an open collaborative knowledge platform. Anybody can create a `Breeb`, a knowledge capsule based on PDFs stored on a Google Drive folder. A `Breeb` can be used by any LLM/chatbot to improve its expertise, reduce hallucinations and give access to sources. Behind the scenes, `Breebs` implements several `Retrieval Augmented Generation (RAG)` models to seamlessly provide useful context at each iteration. ``` from langchain.retrievers import BreebsRetriever ```

Breebs is an open collaborative knowledge platform. Anybody can create a Breeb, a knowledge capsule based on PDFs stored on a Google Drive folder. A Breeb can be used by any LLM/chatbot to improve its expertise, reduce hallucinations and give access to sources. Behind the scenes, Breebs implements several Retrieval Augmented Generation (RAG) models to seamlessly provide useful context at each iteration. from langchain.retrievers import BreebsRetriever

https://python.langchain.com/docs/integrations/providers/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. ``` from langchain_community.llms import 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. from langchain_community.llms import ForefrontAI

https://python.langchain.com/docs/integrations/providers/flyte/

## 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[​](#installation--setup "Direct link to 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[​](#flyte-tasks "Direct link to 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. ``` import osfrom flytekit import ImageSpec, taskfrom langchain.agents import AgentType, initialize_agent, load_toolsfrom langchain.callbacks import FlyteCallbackHandlerfrom langchain.chains import LLMChainfrom langchain_openai import ChatOpenAIfrom langchain_core.prompts import PromptTemplatefrom langchain_core.messages import HumanMessage ``` Set up the necessary environment variables to utilize the OpenAI API and Serp API: ``` # Set OpenAI API keyos.environ["OPENAI_API_KEY"] = "<your_openai_api_key>"# Set Serp API keyos.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. ``` 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[​](#llm "Direct link to LLM") ``` @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([HumanMessage(content="Tell me a joke")]).content ``` ### Chain[​](#chain "Direct link to Chain") ``` @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[​](#agent "Direct link to Agent") ``` @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[​](#execute-the-flyte-tasks-on-kubernetes "Direct link to Execute the Flyte Tasks on Kubernetes") To execute the Flyte tasks on the configured Flyte backend, use the following command: ``` 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: 

Flyte 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 on your system. Flyte Tasks​ A Flyte task 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 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. 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: # 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 or provided separately for each task. To streamline the process of supplying the required dependencies for each Flyte task, you can initialize an ImageSpec object. This approach automatically triggers a Docker build, alleviating the need for users to manually create a Docker image. 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 or GitHub Container Registry (GHCR) 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​ @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([HumanMessage(content="Tell me a joke")]).content Chain​ @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​ @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: 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:

https://python.langchain.com/docs/integrations/providers/browserless/

## Browserless > [Browserless](https://www.browserless.io/docs/start) is a service that allows you to run headless Chrome instances in the cloud. It’s a great way to run browser-based automation at scale without having to worry about managing your own infrastructure. ## Installation and Setup[​](#installation-and-setup "Direct link to Installation and Setup") We have to get the API key [here](https://www.browserless.io/pricing/). ## Document loader[​](#document-loader "Direct link to Document loader") See a [usage example](https://python.langchain.com/docs/integrations/document_loaders/browserless/). ``` from langchain_community.document_loaders import BrowserlessLoader ``` * * * #### Help us out by providing feedback on this documentation page:

Browserless Browserless is a service that allows you to run headless Chrome instances in the cloud. It’s a great way to run browser-based automation at scale without having to worry about managing your own infrastructure. Installation and Setup​ We have to get the API key here. Document loader​ See a usage example. from langchain_community.document_loaders import BrowserlessLoader Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/geopandas/

## 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[​](#installation-and-setup "Direct link to Installation and Setup") We have to install several python packages. ``` pip install -U sodapy pandas geopandas ``` ## Document Loader[​](#document-loader "Direct link to Document Loader") See a [usage example](https://python.langchain.com/docs/integrations/document_loaders/geopandas/). ``` from langchain_community.document_loaders import OpenCityDataLoader ``` * * * #### Help us out by providing feedback on this documentation page:

Geopandas GeoPandas 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. pip install -U sodapy pandas geopandas Document Loader​ See a usage example. from langchain_community.document_loaders import OpenCityDataLoader Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/brave_search/

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

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

https://python.langchain.com/docs/integrations/providers/gitbook/

## 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[​](#installation-and-setup "Direct link to Installation and Setup") There isn't any special setup for it. ## Document Loader[​](#document-loader "Direct link to Document Loader") See a [usage example](https://python.langchain.com/docs/integrations/document_loaders/gitbook/). ``` from langchain_community.document_loaders import GitbookLoader ```

GitBook GitBook 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. from langchain_community.document_loaders import GitbookLoader

https://python.langchain.com/docs/integrations/providers/git/

First, you need to install `GitPython` python package. ``` from langchain_community.document_loaders import GitLoader ```

First, you need to install GitPython python package. from langchain_community.document_loaders import GitLoader

https://python.langchain.com/docs/integrations/providers/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. There are two document loaders available for GitHub. ``` from langchain_community.document_loaders import GitHubIssuesLoaderfrom langchain.document_loaders import GithubFileLoader ```

GitHub 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. There are two document loaders available for GitHub. from langchain_community.document_loaders import GitHubIssuesLoader from langchain.document_loaders import GithubFileLoader

https://python.langchain.com/docs/integrations/providers/google_serper/

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[​](#setup "Direct link to 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[​](#wrappers "Direct link to Wrappers") ### Utility[​](#utility "Direct link to Utility") There exists a GoogleSerperAPIWrapper utility which wraps this API. To import this utility: ``` from langchain_community.utilities import GoogleSerperAPIWrapper ``` You can use it as part of a Self Ask chain: ``` from langchain_community.utilities import GoogleSerperAPIWrapperfrom langchain_openai import OpenAIfrom langchain.agents import initialize_agent, Toolfrom langchain.agents import AgentTypeimport osos.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[​](#output "Direct link to 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, SpainSo the final answer is: El Palmar, Spain> Finished chain.'El Palmar, Spain' ``` For a more detailed walkthrough of this wrapper, see [this notebook](https://python.langchain.com/docs/integrations/tools/google_serper/). ### Tool[​](#tool "Direct link to Tool") You can also easily load this wrapper as a Tool (to use with an Agent). You can do this with: ``` from langchain.agents import load_toolstools = load_tools(["google-serper"]) ``` For more information on tools, see [this page](https://python.langchain.com/docs/modules/tools/).

This page covers how to use the Serper 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 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: from langchain_community.utilities import GoogleSerperAPIWrapper You can use it as part of a Self Ask chain: 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. Tool​ You can also easily load this wrapper as a Tool (to use with an Agent). You can do this with: from langchain.agents import load_tools tools = load_tools(["google-serper"]) For more information on tools, see this page.

https://python.langchain.com/docs/integrations/providers/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. ``` import osos.environ["GOOSEAI_API_KEY"] = "YOUR_API_KEY" ```

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. import os os.environ["GOOSEAI_API_KEY"] = "YOUR_API_KEY"

https://python.langchain.com/docs/integrations/providers/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. There exists a GoldenQueryAPIWrapper utility which wraps this API. To import this utility: ``` from langchain_community.utilities.golden_query import GoldenQueryAPIWrapper ``` You can also easily load this wrapper as a Tool (to use with an Agent). You can do this with:

Golden 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 which enables programmatic access to these results. See the Golden Query API docs for more information. There exists a GoldenQueryAPIWrapper utility which wraps this API. To import this utility: from langchain_community.utilities.golden_query import GoldenQueryAPIWrapper You can also easily load this wrapper as a Tool (to use with an Agent). You can do this with:

https://python.langchain.com/docs/integrations/providers/gpt4all/

## 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[​](#installation-and-setup "Direct link to 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`(Best overall fast chat model): ``` mkdir modelswget https://gpt4all.io/models/gguf/mistral-7b-openorca.Q4_0.gguf -O models/mistral-7b-openorca.Q4_0.gguf ``` ## Usage[​](#usage "Direct link to Usage") ### GPT4All[​](#gpt4all-1 "Direct link to GPT4All") To use the GPT4All wrapper, you need to provide the path to the pre-trained model file and the model's configuration. ``` from langchain_community.llms import GPT4All# Instantiate the model. Callbacks support token-wise streamingmodel = GPT4All(model="./models/mistral-7b-openorca.Q4_0.gguf", n_threads=8)# Generate textresponse = model("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. ``` from langchain_community.llms import GPT4Allfrom langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler# There are many CallbackHandlers supported, such as# from langchain.callbacks.streamlit import StreamlitCallbackHandlercallbacks = [StreamingStdOutCallbackHandler()]model = GPT4All(model="./models/mistral-7b-openorca.Q4_0.gguf", n_threads=8)# Generate text. Tokens are streamed through the callback manager.model("Once upon a time, ", callbacks=callbacks) ``` ## Model File[​](#model-file "Direct link to Model File") You can find links to model file downloads in the [https://gpt4all.io/](https://gpt4all.io/index.html). For a more detailed walkthrough of this, see [this notebook](https://python.langchain.com/docs/integrations/llms/gpt4all/) * * * #### Help us out by providing feedback on this documentation page:

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 and place it in your desired directory In this example, We are using mistral-7b-openorca.Q4_0.gguf(Best overall fast chat model): 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. 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("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. 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("Once upon a time, ", callbacks=callbacks) Model File​ You can find links to model file downloads in the https://gpt4all.io/. For a more detailed walkthrough of this, see this notebook Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/graphsignal/

## 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[​](#installation-and-setup "Direct link to 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[​](#tracing-and-monitoring "Direct link to 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: ``` import graphsignalgraphsignal.configure(deployment='my-langchain-app-prod') ``` To additionally trace any function or code, you can use a decorator or a context manager: ``` @graphsignal.trace_functiondef handle_request(): chain.run("some initial text") ``` ``` with graphsignal.start_trace('my-chain'): chain.run("some initial text") ``` Optionally, enable profiling to record function-level statistics for each trace. ``` 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.

Graphsignal This page covers how to use Graphsignal 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 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. Initialize the tracer by providing a deployment name: 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: @graphsignal.trace_function def handle_request(): chain.run("some initial text") with graphsignal.start_trace('my-chain'): chain.run("some initial text") Optionally, enable profiling to record function-level statistics for each trace. with graphsignal.start_trace( 'my-chain', options=graphsignal.TraceOptions(enable_profiling=True)): chain.run("some initial text") See the Quick Start guide for complete setup instructions.

https://python.langchain.com/docs/integrations/providers/dataherald/

This page covers how to use the `Dataherald API` within LangChain. There exists a DataheraldAPIWrapper utility which wraps this API. To import this utility: ``` from langchain_community.utilities.dataherald import DataheraldAPIWrapperfrom langchain_community.tools.dataherald.tool import DataheraldTextToSQLfrom langchain_openai import ChatOpenAIfrom langchain import hubfrom langchain.agents import AgentExecutor, create_react_agent, load_toolsapi_wrapper = DataheraldAPIWrapper(db_connection_id="<db_connection_id>")tool = DataheraldTextToSQL(api_wrapper=api_wrapper)llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)prompt = hub.pull("hwchase17/react")agent = create_react_agent(llm, tools, prompt)agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)agent_executor.invoke({"input":"Return the sql for this question: How many employees are in the company?"}) ```

This page covers how to use the Dataherald API within LangChain. There exists a DataheraldAPIWrapper utility which wraps this API. To import this utility: from langchain_community.utilities.dataherald import DataheraldAPIWrapper from langchain_community.tools.dataherald.tool import DataheraldTextToSQL from langchain_openai import ChatOpenAI from langchain import hub from langchain.agents import AgentExecutor, create_react_agent, load_tools api_wrapper = DataheraldAPIWrapper(db_connection_id="<db_connection_id>") tool = DataheraldTextToSQL(api_wrapper=api_wrapper) llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0) prompt = hub.pull("hwchase17/react") agent = create_react_agent(llm, tools, prompt) agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) agent_executor.invoke({"input":"Return the sql for this question: How many employees are in the company?"})

https://python.langchain.com/docs/integrations/providers/deepsparse/

This page covers how to use the [DeepSparse](https://github.com/neuralmagic/deepsparse) inference runtime within LangChain. It is broken into two parts: installation and setup, and then examples of DeepSparse usage. ``` config = {'max_generated_tokens': 256}llm = DeepSparse(model='zoo:nlg/text_generation/codegen_mono-350m/pytorch/huggingface/bigpython_bigquery_thepile/base-none', config=config) ```

This page covers how to use the DeepSparse inference runtime within LangChain. It is broken into two parts: installation and setup, and then examples of DeepSparse usage. config = {'max_generated_tokens': 256} llm = DeepSparse(model='zoo:nlg/text_generation/codegen_mono-350m/pytorch/huggingface/bigpython_bigquery_thepile/base-none', config=config)

https://python.langchain.com/docs/integrations/providers/gradient/

There exists an Gradient LLM wrapper, which you can access with See a [usage example](https://python.langchain.com/docs/integrations/llms/gradient/). ``` from langchain_community.llms import GradientLLM ```

There exists an Gradient LLM wrapper, which you can access with See a usage example. from langchain_community.llms import GradientLLM

https://python.langchain.com/docs/integrations/providers/deepinfra/

This page covers how to use the `DeepInfra` ecosystem within `LangChain`. It is broken into two parts: installation and setup, and then references to specific DeepInfra wrappers. DeepInfra provides a range of Open Source LLMs ready for deployment. ``` from langchain_community.llms import DeepInfra ```

This page covers how to use the DeepInfra ecosystem within LangChain. It is broken into two parts: installation and setup, and then references to specific DeepInfra wrappers. DeepInfra provides a range of Open Source LLMs ready for deployment. from langchain_community.llms import DeepInfra

https://python.langchain.com/docs/integrations/providers/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. Once grobid is installed and up and running (you can check by accessing it http://localhost:8070), you're ready to go. ``` from langchain_community.document_loaders.parsers import GrobidParserfrom langchain_community.document_loaders.generic import GenericLoader#Produce chunks from article paragraphsloader = GenericLoader.from_filesystem( "/Users/31treehaus/Desktop/Papers/", glob="*", suffixes=[".pdf"], parser= GrobidParser(segment_sentences=False))docs = loader.load()#Produce chunks from article sentencesloader = GenericLoader.from_filesystem( "/Users/31treehaus/Desktop/Papers/", glob="*", suffixes=[".pdf"], parser= GrobidParser(segment_sentences=True))docs = loader.load() ```

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. Once grobid is installed and up and running (you can check by accessing it http://localhost:8070), you're ready to go. 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()

https://python.langchain.com/docs/integrations/providers/diffbot/

[Diffbot](https://docs.diffbot.com/docs) is a service to read web pages. Unlike traditional web scraping tools, `Diffbot` doesn't require any rules to read the content on a page. It starts with computer vision, which classifies a page into one of 20 possible types. Content is then interpreted by a machine learning model trained to identify the key attributes on a page based on its type. The result is a website transformed into clean-structured data (like JSON or CSV), ready for your application. ``` from langchain_community.document_loaders import DiffbotLoader ```

Diffbot is a service to read web pages. Unlike traditional web scraping tools, Diffbot doesn't require any rules to read the content on a page. It starts with computer vision, which classifies a page into one of 20 possible types. Content is then interpreted by a machine learning model trained to identify the key attributes on a page based on its type. The result is a website transformed into clean-structured data (like JSON or CSV), ready for your application. from langchain_community.document_loaders import DiffbotLoader

https://python.langchain.com/docs/integrations/providers/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: 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! ``` pip install langchain-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: Want more Groq? Check out our website for more resources and join our Discord community to connect with our developers! pip install langchain-groq

https://python.langchain.com/docs/integrations/providers/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. 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. **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. ``` from langchain_community.document_loaders import DiscordChatLoader ```

Discord 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. 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. 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. from langchain_community.document_loaders import DiscordChatLoader

https://python.langchain.com/docs/integrations/providers/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. We need to install `docarray` python package. LangChain provides an access to the `In-memory` and `HNSW` vector stores from the `DocArray` library. ``` from langchain_community.vectorstores DocArrayHnswSearch ```

DocArray 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. We need to install docarray python package. LangChain provides an access to the In-memory and HNSW vector stores from the DocArray library. from langchain_community.vectorstores DocArrayHnswSearch

https://python.langchain.com/docs/integrations/providers/gutenberg/

There isn't any special setup for it. ``` from langchain_community.document_loaders import GutenbergLoader ```

There isn't any special setup for it. from langchain_community.document_loaders import GutenbergLoader

https://python.langchain.com/docs/integrations/providers/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. ``` from langchain_community.document_loaders import DoctranQATransformer ```

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. from langchain_community.document_loaders import DoctranQATransformer

https://python.langchain.com/docs/integrations/providers/hacker_news/

## 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[​](#installation-and-setup "Direct link to Installation and Setup") There isn't any special setup for it. ## Document Loader[​](#document-loader "Direct link to Document Loader") See a [usage example](https://python.langchain.com/docs/integrations/document_loaders/hacker_news/). ``` from langchain_community.document_loaders import HNLoader ``` * * * #### Help us out by providing feedback on this documentation page:

Hacker News 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. from langchain_community.document_loaders import HNLoader Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/dingo/

This page covers how to use the DingoDB ecosystem within LangChain. It is broken into two parts: installation and setup, and then references to specific DingoDB wrappers. There exists a wrapper around DingoDB indexes, allowing you to use it as a vectorstore, whether for semantic search or example selection. ``` from langchain_community.vectorstores import Dingo ```

This page covers how to use the DingoDB ecosystem within LangChain. It is broken into two parts: installation and setup, and then references to specific DingoDB wrappers. There exists a wrapper around DingoDB indexes, allowing you to use it as a vectorstore, whether for semantic search or example selection. from langchain_community.vectorstores import Dingo

https://python.langchain.com/docs/integrations/providers/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. With your LangChain environment you can just add the following parameter. 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. ``` from langchain_openai import OpenAIimport openaiopenai.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(text)) ```

Helicone is an open-source observability platform that proxies your OpenAI traffic and provides you key insights into your spend, latency and usage. With your LangChain environment you can just add the following parameter. Now head over to helicone.ai to create your account, and add your OpenAI API key within our dashboard to view your logs. 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(text))

https://python.langchain.com/docs/integrations/providers/docugami/

## 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[​](#installation-and-setup "Direct link to Installation and Setup") ``` pip install dgml-utilspip install docugami-langchain ``` ## Document Loader[​](#document-loader "Direct link to Document Loader") See a [usage example](https://python.langchain.com/docs/integrations/document_loaders/docugami/). ``` from docugami_langchain.document_loaders import DocugamiLoader ``` * * * #### Help us out by providing feedback on this documentation page:

Docugami Docugami 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​ pip install dgml-utils pip install docugami-langchain Document Loader​ See a usage example. from docugami_langchain.document_loaders import DocugamiLoader Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/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. 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. ``` from langchain_community.llms.manifest import ManifestWrapper ```

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. 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. from langchain_community.llms.manifest import ManifestWrapper

https://python.langchain.com/docs/integrations/providers/docusaurus/

## Docusaurus > [Docusaurus](https://docusaurus.io/) is a static-site generator which provides out-of-the-box documentation features. ## Installation and Setup[​](#installation-and-setup "Direct link to Installation and Setup") ``` pip install -U beautifulsoup4 lxml ``` ## Document Loader[​](#document-loader "Direct link to Document Loader") See a [usage example](https://python.langchain.com/docs/integrations/document_loaders/docusaurus/). ``` from langchain_community.document_loaders import DocusaurusLoader ``` * * * #### Help us out by providing feedback on this documentation page:

Docusaurus Docusaurus is a static-site generator which provides out-of-the-box documentation features. Installation and Setup​ pip install -U beautifulsoup4 lxml Document Loader​ See a usage example. from langchain_community.document_loaders import DocusaurusLoader Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/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. ``` pip install hologres-vector ```

Hologres 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. pip install hologres-vector

https://python.langchain.com/docs/integrations/providers/dropbox/

## 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[​](#installation-and-setup "Direct link to Installation and Setup") See the detailed [installation guide](https://python.langchain.com/docs/integrations/document_loaders/dropbox/#prerequisites). ## Document Loader[​](#document-loader "Direct link to Document Loader") See a [usage example](https://python.langchain.com/docs/integrations/document_loaders/dropbox/). ``` from langchain_community.document_loaders import DropboxLoader ``` * * * #### Help us out by providing feedback on this documentation page:

Dropbox 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. Document Loader​ See a usage example. from langchain_community.document_loaders import DropboxLoader Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/html2text/

The ASCII also happens to be a valid `Markdown` (a text-to-HTML format). ``` from langchain_community.document_loaders import Html2TextTransformer ```

The ASCII also happens to be a valid Markdown (a text-to-HTML format). from langchain_community.document_loaders import Html2TextTransformer

https://python.langchain.com/docs/integrations/providers/huawei/

## 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[​](#installation-and-setup "Direct link to Installation and Setup") To access the `Huawei Cloud`, you need an access token. You also have to install a python library: ``` pip install -U esdk-obs-python ``` ## Document Loader[​](#document-loader "Direct link to Document Loader") ### Huawei OBS Directory[​](#huawei-obs-directory "Direct link to Huawei OBS Directory") See a [usage example](https://python.langchain.com/docs/integrations/document_loaders/huawei_obs_directory/). ``` from langchain_community.document_loaders import OBSDirectoryLoader ``` ### Huawei OBS File[​](#huawei-obs-file "Direct link to Huawei OBS File") See a [usage example](https://python.langchain.com/docs/integrations/document_loaders/huawei_obs_file/). ``` from langchain_community.document_loaders.obs_file import OBSFileLoader ``` * * * #### Help us out by providing feedback on this documentation page:

Huawei Huawei Technologies Co., Ltd. is a Chinese multinational digital communications technology corporation. Huawei Cloud 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: pip install -U esdk-obs-python Document Loader​ Huawei OBS Directory​ See a usage example. from langchain_community.document_loaders import OBSDirectoryLoader Huawei OBS File​ See a usage example. from langchain_community.document_loaders.obs_file import OBSFileLoader Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/dspy/

## DSPy [DSPy](https://github.com/stanfordnlp/dspy) is a fantastic framework for LLMs that introduces an automatic compiler that teaches LMs how to conduct the declarative steps in your program. Specifically, the DSPy compiler will internally trace your program and then craft high-quality prompts for large LMs (or train automatic finetunes for small LMs) to teach them the steps of your task. Thanks to [Omar Khattab](https://twitter.com/lateinteraction) we have an integration! It works with any LCEL chains with some minor modifications. This short tutorial demonstrates how this proof-of-concept feature works. _This will not give you the full power of DSPy or LangChain yet, but we will expand it if there’s high demand._ Note: this was slightly modified from the original example Omar wrote for DSPy. If you are interested in LangChain \\<\> DSPy but coming from the DSPy side, I’d recommend checking that out. You can find that [here](https://github.com/stanfordnlp/dspy/blob/main/examples/tweets/compiling_langchain.ipynb). Let’s take a look at an example. In this example we will make a simple RAG pipeline. We will use DSPy to “compile” our program and learn an optimized prompt. ## Install dependencies[​](#install-dependencies "Direct link to Install dependencies") !pip install -U dspy-ai !pip install -U openai jinja2 !pip install -U langchain langchain-community langchain-openai langchain-core ## Setup[​](#setup "Direct link to Setup") We will be using OpenAI, so we should set an API key ``` import getpassimport osos.environ["OPENAI_API_KEY"] = getpass.getpass() ``` We can now set up our retriever. For our retriever we will use a ColBERT retriever through DSPy, though this will work with any retriever. ``` import dspycolbertv2 = dspy.ColBERTv2(url="http://20.102.90.50:2017/wiki17_abstracts") ``` ``` from langchain.cache import SQLiteCachefrom langchain.globals import set_llm_cachefrom langchain_openai import OpenAIset_llm_cache(SQLiteCache(database_path="cache.db"))llm = OpenAI(model_name="gpt-3.5-turbo-instruct", temperature=0)def retrieve(inputs): return [doc["text"] for doc in colbertv2(inputs["question"], k=5)] ``` ``` [{'text': 'Cycling | Cycling, also called bicycling or biking, is the use of bicycles for transport, recreation, exercise or sport. Persons engaged in cycling are referred to as "cyclists", "bikers", or less commonly, as "bicyclists". Apart from two-wheeled bicycles, "cycling" also includes the riding of unicycles, tricycles, quadracycles, recumbent and similar human-powered vehicles (HPVs).', 'pid': 2201868, 'rank': 1, 'score': 27.078739166259766, 'prob': 0.3544841299722533, 'long_text': 'Cycling | Cycling, also called bicycling or biking, is the use of bicycles for transport, recreation, exercise or sport. Persons engaged in cycling are referred to as "cyclists", "bikers", or less commonly, as "bicyclists". Apart from two-wheeled bicycles, "cycling" also includes the riding of unicycles, tricycles, quadracycles, recumbent and similar human-powered vehicles (HPVs).'}, {'text': 'Cycling (ice hockey) | In ice hockey, cycling is an offensive strategy that moves the puck along the boards in the offensive zone to create a scoring chance by making defenders tired or moving them out of position.', 'pid': 312153, 'rank': 2, 'score': 26.109302520751953, 'prob': 0.13445464524590262, 'long_text': 'Cycling (ice hockey) | In ice hockey, cycling is an offensive strategy that moves the puck along the boards in the offensive zone to create a scoring chance by making defenders tired or moving them out of position.'}, {'text': 'Bicycle | A bicycle, also called a cycle or bike, is a human-powered, pedal-driven, single-track vehicle, having two wheels attached to a frame, one behind the other. A is called a cyclist, or bicyclist.', 'pid': 2197695, 'rank': 3, 'score': 25.849220275878906, 'prob': 0.10366294133944996, 'long_text': 'Bicycle | A bicycle, also called a cycle or bike, is a human-powered, pedal-driven, single-track vehicle, having two wheels attached to a frame, one behind the other. A is called a cyclist, or bicyclist.'}, {'text': 'USA Cycling | USA Cycling or USAC, based in Colorado Springs, Colorado, is the national governing body for bicycle racing in the United States. It covers the disciplines of road, track, mountain bike, cyclo-cross, and BMX across all ages and ability levels. In 2015, USAC had a membership of 61,631 individual members.', 'pid': 3821927, 'rank': 4, 'score': 25.61395263671875, 'prob': 0.08193096873942958, 'long_text': 'USA Cycling | USA Cycling or USAC, based in Colorado Springs, Colorado, is the national governing body for bicycle racing in the United States. It covers the disciplines of road, track, mountain bike, cyclo-cross, and BMX across all ages and ability levels. In 2015, USAC had a membership of 61,631 individual members.'}, {'text': 'Vehicular cycling | Vehicular cycling (also known as bicycle driving) is the practice of riding bicycles on roads in a manner that is in accordance with the principles for driving in traffic.', 'pid': 3058888, 'rank': 5, 'score': 25.35515785217285, 'prob': 0.06324918635213703, 'long_text': 'Vehicular cycling | Vehicular cycling (also known as bicycle driving) is the practice of riding bicycles on roads in a manner that is in accordance with the principles for driving in traffic.'}, {'text': 'Road cycling | Road cycling is the most widespread form of cycling. It includes recreational, racing, and utility cycling. Road cyclists are generally expected to obey the same rules and laws as other vehicle drivers or riders and may also be vehicular cyclists.', 'pid': 3392359, 'rank': 6, 'score': 25.274639129638672, 'prob': 0.058356079351563846, 'long_text': 'Road cycling | Road cycling is the most widespread form of cycling. It includes recreational, racing, and utility cycling. Road cyclists are generally expected to obey the same rules and laws as other vehicle drivers or riders and may also be vehicular cyclists.'}, {'text': 'Cycling South Africa | Cycling South Africa or Cycling SA is the national governing body of cycle racing in South Africa. Cycling SA is a member of the "Confédération Africaine de Cyclisme" and the "Union Cycliste Internationale" (UCI). It is affiliated to the South African Sports Confederation and Olympic Committee (SASCOC) as well as the Department of Sport and Recreation SA. Cycling South Africa regulates the five major disciplines within the sport, both amateur and professional, which include: road cycling, mountain biking, BMX biking, track cycling and para-cycling.', 'pid': 2508026, 'rank': 7, 'score': 25.24260711669922, 'prob': 0.05651643767006817, 'long_text': 'Cycling South Africa | Cycling South Africa or Cycling SA is the national governing body of cycle racing in South Africa. Cycling SA is a member of the "Confédération Africaine de Cyclisme" and the "Union Cycliste Internationale" (UCI). It is affiliated to the South African Sports Confederation and Olympic Committee (SASCOC) as well as the Department of Sport and Recreation SA. Cycling South Africa regulates the five major disciplines within the sport, both amateur and professional, which include: road cycling, mountain biking, BMX biking, track cycling and para-cycling.'}, {'text': 'Cycle sport | Cycle sport is competitive physical activity using bicycles. There are several categories of bicycle racing including road bicycle racing, time trialling, cyclo-cross, mountain bike racing, track cycling, BMX, and cycle speedway. Non-racing cycling sports include artistic cycling, cycle polo, freestyle BMX and mountain bike trials. The Union Cycliste Internationale (UCI) is the world governing body for cycling and international competitive cycling events. The International Human Powered Vehicle Association is the governing body for human-powered vehicles that imposes far fewer restrictions on their design than does the UCI. The UltraMarathon Cycling Association is the governing body for many ultra-distance cycling races.', 'pid': 3394121, 'rank': 8, 'score': 25.170495986938477, 'prob': 0.05258444735141742, 'long_text': 'Cycle sport | Cycle sport is competitive physical activity using bicycles. There are several categories of bicycle racing including road bicycle racing, time trialling, cyclo-cross, mountain bike racing, track cycling, BMX, and cycle speedway. Non-racing cycling sports include artistic cycling, cycle polo, freestyle BMX and mountain bike trials. The Union Cycliste Internationale (UCI) is the world governing body for cycling and international competitive cycling events. The International Human Powered Vehicle Association is the governing body for human-powered vehicles that imposes far fewer restrictions on their design than does the UCI. The UltraMarathon Cycling Association is the governing body for many ultra-distance cycling races.'}, {'text': "Cycling UK | Cycling UK is the brand name of the Cyclists' Touring Club or CTC. It is a charitable membership organisation supporting cyclists and promoting bicycle use. Cycling UK is registered at Companies House (as “Cyclists’ Touring Club”), and covered by company law; it is the largest such organisation in the UK. It works at a national and local level to lobby for cyclists' needs and wants, provides services to members, and organises local groups for local activism and those interested in recreational cycling. The original Cyclists' Touring Club began in the nineteenth century with a focus on amateur road cycling but these days has a much broader sphere of interest encompassing everyday transport, commuting and many forms of recreational cycling. Prior to April 2016, Cycling UK operated under the brand CTC, the national cycling charity. As of January 2007, the organisation's president was the newsreader Jon Snow.", 'pid': 1841483, 'rank': 9, 'score': 25.166988372802734, 'prob': 0.05240032450529368, 'long_text': "Cycling UK | Cycling UK is the brand name of the Cyclists' Touring Club or CTC. It is a charitable membership organisation supporting cyclists and promoting bicycle use. Cycling UK is registered at Companies House (as “Cyclists’ Touring Club”), and covered by company law; it is the largest such organisation in the UK. It works at a national and local level to lobby for cyclists' needs and wants, provides services to members, and organises local groups for local activism and those interested in recreational cycling. The original Cyclists' Touring Club began in the nineteenth century with a focus on amateur road cycling but these days has a much broader sphere of interest encompassing everyday transport, commuting and many forms of recreational cycling. Prior to April 2016, Cycling UK operated under the brand CTC, the national cycling charity. As of January 2007, the organisation's president was the newsreader Jon Snow."}, {'text': 'Cycling in the Netherlands | Cycling is a ubiquitous mode of transport in the Netherlands, with 36% of the people listing the bicycle as their most frequent mode of transport on a typical day as opposed to the car by 45% and public transport by 11%. Cycling has a modal share of 27% of all trips (urban and rural) nationwide. In cities this is even higher, such as Amsterdam which has 38%, though the smaller Dutch cities well exceed that: for instance Zwolle (pop. ~123,000) has 46% and the university town of Groningen (pop. ~198,000) has 31%. This high modal share for bicycle travel is enabled by excellent cycling infrastructure such as cycle paths, cycle tracks, protected intersections, ubiquitous bicycle parking and by making cycling routes shorter, quicker and more direct than car routes.', 'pid': 1196118, 'rank': 10, 'score': 24.954299926757812, 'prob': 0.0423608394724844, 'long_text': 'Cycling in the Netherlands | Cycling is a ubiquitous mode of transport in the Netherlands, with 36% of the people listing the bicycle as their most frequent mode of transport on a typical day as opposed to the car by 45% and public transport by 11%. Cycling has a modal share of 27% of all trips (urban and rural) nationwide. In cities this is even higher, such as Amsterdam which has 38%, though the smaller Dutch cities well exceed that: for instance Zwolle (pop. ~123,000) has 46% and the university town of Groningen (pop. ~198,000) has 31%. This high modal share for bicycle travel is enabled by excellent cycling infrastructure such as cycle paths, cycle tracks, protected intersections, ubiquitous bicycle parking and by making cycling routes shorter, quicker and more direct than car routes.'}] ``` ## Normal LCEL[​](#normal-lcel "Direct link to Normal LCEL") First, let’s create a simple RAG pipeline with LCEL like we would normally. For illustration, let’s tackle the following task. **Task:** Build a RAG system for generating informative tweets. * **Input:** A factual question, which may be fairly complex. * **Output:** An engaging tweet that correctly answers the question from the retrieved info. Let’s use LangChain’s expression language (LCEL) to illustrate this. Any prompt here will do, we will optimize the final prompt with DSPy. Considering that, let’s just keep it to the barebones: **Given {context}, answer the question {question} as a tweet.** ``` # From LangChain, import standard modules for prompting.from langchain_core.output_parsers import StrOutputParserfrom langchain_core.prompts import PromptTemplatefrom langchain_core.runnables import RunnablePassthrough# Just a simple prompt for this task. It's fine if it's complex too.prompt = PromptTemplate.from_template( "Given {context}, answer the question `{question}` as a tweet.")# This is how you'd normally build a chain with LCEL. This chain does retrieval then generation (RAG).vanilla_chain = ( RunnablePassthrough.assign(context=retrieve) | prompt | llm | StrOutputParser()) ``` ## LCEL \\<\> DSPy[​](#lcel-dspy "Direct link to lcel-dspy") In order to use LangChain with DSPy, you need to make two minor modifications **LangChainPredict** You need to change from doing `prompt | llm` to using `LangChainPredict(prompt, llm)` from `dspy`. This is a wrapper which will bind your prompt and llm together so you can optimize them **LangChainModule** This is a wrapper which wraps your final LCEL chain so that DSPy can optimize the whole thing ``` # From DSPy, import the modules that know how to interact with LangChain LCEL.from dspy.predict.langchain import LangChainModule, LangChainPredict# This is how to wrap it so it behaves like a DSPy program.# Just Replace every pattern like `prompt | llm` with `LangChainPredict(prompt, llm)`.zeroshot_chain = ( RunnablePassthrough.assign(context=retrieve) | LangChainPredict(prompt, llm) | StrOutputParser())# Now we wrap it in LangChainModulezeroshot_chain = LangChainModule( zeroshot_chain) # then wrap the chain in a DSPy module. ``` ## Trying the Module[​](#trying-the-module "Direct link to Trying the Module") After this, we can use it as both a LangChain runnable and a DSPy module! ``` question = "In what region was Eddy Mazzoleni born?"zeroshot_chain.invoke({"question": question}) ``` ``` ' Eddy Mazzoleni, born in Bergamo, Italy, is a professional road cyclist who rode for UCI ProTour Astana Team. #cyclist #Italy' ``` Ah that sounds about right! (It’s technically not perfect: we asked for the region not the city. We can do better below.) Inspecting questions and answers manually is very important to get a sense of your system. However, a good system designer always looks to iteratively benchmark their work to quantify progress! To do this, we need two things: the metric we want to maximize and a (tiny) dataset of examples for our system. Are there pre-defined metrics for good tweets? Should I label 100,000 tweets by hand? Probably not. We can easily do something reasonable, though, until you start getting data in production! ## Load Data[​](#load-data "Direct link to Load Data") In order to compile our chain, we need a dataset to work with. This dataset just needs to be raw inputs and outputs. For our purposes, we will use HotPotQA dataset Note: Notice that our dataset doesn’t actually include any tweets! It only has questions and answers. That’s OK, our metric will take care of evaluating outputs in tweet form. ``` import dspyfrom dspy.datasets import HotPotQA# Load the dataset.dataset = HotPotQA( train_seed=1, train_size=200, eval_seed=2023, dev_size=200, test_size=0, keep_details=True,)# Tell DSPy that the 'question' field is the input. Any other fields are labels and/or metadata.trainset = [x.without("id", "type").with_inputs("question") for x in dataset.train]devset = [x.without("id", "type").with_inputs("question") for x in dataset.dev]valset, devset = devset[:50], devset[50:] ``` ``` /Users/harrisonchase/.pyenv/versions/3.11.1/envs/langchain-3-11/lib/python3.11/site-packages/datasets/table.py:1421: FutureWarning: promote has been superseded by mode='default'. table = cls._concat_blocks(blocks, axis=0) ``` ## Define a metic[​](#define-a-metic "Direct link to Define a metic") We now need to define a metric. This will be used to determine which runs were successful and we can learn from. Here we will use DSPy’s metrics, though you can write your own. ``` # Define the signature for autoamtic assessments.class Assess(dspy.Signature): """Assess the quality of a tweet along the specified dimension.""" context = dspy.InputField(desc="ignore if N/A") assessed_text = dspy.InputField() assessment_question = dspy.InputField() assessment_answer = dspy.OutputField(desc="Yes or No")gpt4T = dspy.OpenAI(model="gpt-4-1106-preview", max_tokens=1000, model_type="chat")METRIC = Nonedef metric(gold, pred, trace=None): question, answer, tweet = gold.question, gold.answer, pred.output context = colbertv2(question, k=5) engaging = "Does the assessed text make for a self-contained, engaging tweet?" faithful = "Is the assessed text grounded in the context? Say no if it includes significant facts not in the context." correct = ( f"The text above is should answer `{question}`. The gold answer is `{answer}`." ) correct = f"{correct} Does the assessed text above contain the gold answer?" with dspy.context(lm=gpt4T): faithful = dspy.Predict(Assess)( context=context, assessed_text=tweet, assessment_question=faithful ) correct = dspy.Predict(Assess)( context="N/A", assessed_text=tweet, assessment_question=correct ) engaging = dspy.Predict(Assess)( context="N/A", assessed_text=tweet, assessment_question=engaging ) correct, engaging, faithful = [ m.assessment_answer.split()[0].lower() == "yes" for m in [correct, engaging, faithful] ] score = (correct + engaging + faithful) if correct and (len(tweet) <= 280) else 0 if METRIC is not None: if METRIC == "correct": return correct if METRIC == "engaging": return engaging if METRIC == "faithful": return faithful if trace is not None: return score >= 3 return score / 3.0 ``` ## Evaluate Baseline[​](#evaluate-baseline "Direct link to Evaluate Baseline") Okay, let’s evaluate the unoptimized “zero-shot” version of our chain, converted from our LangChain LCEL object. ``` from dspy.evaluate.evaluate import Evaluate ``` ``` evaluate = Evaluate( metric=metric, devset=devset, num_threads=8, display_progress=True, display_table=5)evaluate(zeroshot_chain) ``` ``` Average Metric: 62.99999999999998 / 150 (42.0): 100%|██| 150/150 [01:14<00:00, 2.02it/s]/Users/harrisonchase/.pyenv/versions/3.11.1/envs/langchain-3-11/lib/python3.11/site-packages/dspy/evaluate/evaluate.py:126: FutureWarning: DataFrame.applymap has been deprecated. Use DataFrame.map instead. df = df.applymap(truncate_cell) ``` ``` Average Metric: 62.99999999999998 / 150 (42.0%) ``` | | question | answer | gold\_titles | output | tweet\_response | metric | | --- | --- | --- | --- | --- | --- | --- | | 0 | Who was a producer who produced albums for both rock bands Juke Karten and Thirty Seconds to Mars? | Brian Virtue | {'Thirty Seconds to Mars', 'Levolution (album)'} | Brian Virtue, who has worked with bands like Jane's Addiction and Velvet Revolver, produced albums for both Juke Kartel and Thirty Seconds to Mars. #BrianVirtue... | Brian Virtue, who has worked with bands like Jane's Addiction and Velvet Revolver, produced albums for both Juke Kartel and Thirty Seconds to Mars. #BrianVirtue... | 1.0 | | 1 | Are both the University of Chicago and Syracuse University public universities? | no | {'Syracuse University', 'University of Chicago'} | No, only Syracuse University is a public university. The University of Chicago is a private research university. #university #publicvsprivate | No, only Syracuse University is a public university. The University of Chicago is a private research university. #university #publicvsprivate | 0.3333333333333333 | | 2 | In what region was Eddy Mazzoleni born? | Lombardy, northern Italy | {'Eddy Mazzoleni', 'Bergamo'} | Eddy Mazzoleni, born in Bergamo, Italy, is a professional road cyclist who rode for UCI ProTour Astana Team. #cyclist #Italy | Eddy Mazzoleni, born in Bergamo, Italy, is a professional road cyclist who rode for UCI ProTour Astana Team. #cyclist #Italy | 0.0 | | 3 | Who edited the 1990 American romantic comedy film directed by Garry Marshall? | Raja Raymond Gosnell | {'Raja Gosnell', 'Pretty Woman'} | J. F. Lawton wrote the screenplay for Pretty Woman, the 1990 American romantic comedy film directed by Garry Marshall. #PrettyWoman #GarryMarshall #JFLawton | J. F. Lawton wrote the screenplay for Pretty Woman, the 1990 American romantic comedy film directed by Garry Marshall. #PrettyWoman #GarryMarshall #JFLawton | 0.0 | | 4 | Burrs Country Park railway station is what stop on the railway line that runs between Heywood and Rawtenstall | seventh | {'Burrs Country Park railway station', 'East Lancashire Railway'} | Burrs Country Park railway station is the seventh stop on the East Lancashire Railway line that runs between Heywood and Rawtenstall. | Burrs Country Park railway station is the seventh stop on the East Lancashire Railway line that runs between Heywood and Rawtenstall. | 1.0 | ... 145 more rows not displayed ... Okay, cool. Our zeroshot\_chain gets about 42.00% on the 150 questions from the devset. The table above shows some examples. For instance: * Question: Who was a producer who produced albums for both rock bands Juke Karten and Thirty Seconds to Mars? * Tweet: Brian Virtue, who has worked with bands like Jane’s Addiction and Velvet Revolver, produced albums for both Juke Kartel and Thirty Seconds to Mars, showcasing… \[truncated\] * Metric: 1.0 (A tweet that is correct, faithful, and engaging!\*) footnote: \* At least according to our metric, which is just a DSPy program, so it too can be optimized if you’d like! Topic for another notebook, though. ## Optimize[​](#optimize "Direct link to Optimize") Now, let’s optimize performance ``` from dspy.teleprompt import BootstrapFewShotWithRandomSearch ``` ``` # Set up the optimizer. We'll use very minimal hyperparameters for this example.# Just do random search with ~3 attempts, and in each attempt, bootstrap <= 3 traces.optimizer = BootstrapFewShotWithRandomSearch( metric=metric, max_bootstrapped_demos=3, num_candidate_programs=3)# Now use the optimizer to *compile* the chain. This could take 5-10 minutes, unless it's cached.optimized_chain = optimizer.compile(zeroshot_chain, trainset=trainset, valset=valset) ``` ``` Going to sample between 1 and 3 traces per predictor.Will attempt to train 3 candidate sets.Average Metric: 22.33333333333334 / 50 (44.7%)Score: 44.67 for set: [0]New best score: 44.67 for seed -3Scores so far: [44.67]Best score: 44.67Average Metric: 22.33333333333334 / 50 (44.7%)Score: 44.67 for set: [16]Scores so far: [44.67, 44.67]Best score: 44.67Bootstrapped 3 full traces after 9 examples in round 0.Average Metric: 24.666666666666668 / 50 (49.3%)Score: 49.33 for set: [16]New best score: 49.33 for seed -1Scores so far: [44.67, 44.67, 49.33]Best score: 49.33Average of max per entry across top 1 scores: 0.49333333333333335Average of max per entry across top 2 scores: 0.5533333333333335Average of max per entry across top 3 scores: 0.5533333333333335Average of max per entry across top 5 scores: 0.5533333333333335Average of max per entry across top 8 scores: 0.5533333333333335Average of max per entry across top 9999 scores: 0.5533333333333335Bootstrapped 2 full traces after 13 examples in round 0.Average Metric: 25.66666666666667 / 50 (51.3%)Score: 51.33 for set: [16]New best score: 51.33 for seed 0Scores so far: [44.67, 44.67, 49.33, 51.33]Best score: 51.33Average of max per entry across top 1 scores: 0.5133333333333334Average of max per entry across top 2 scores: 0.5666666666666668Average of max per entry across top 3 scores: 0.6000000000000001Average of max per entry across top 5 scores: 0.6000000000000001Average of max per entry across top 8 scores: 0.6000000000000001Average of max per entry across top 9999 scores: 0.6000000000000001Bootstrapped 1 full traces after 2 examples in round 0.Average Metric: 26.33333333333334 / 50 (52.7%)Score: 52.67 for set: [16]New best score: 52.67 for seed 1Scores so far: [44.67, 44.67, 49.33, 51.33, 52.67]Best score: 52.67Average of max per entry across top 1 scores: 0.5266666666666667Average of max per entry across top 2 scores: 0.56Average of max per entry across top 3 scores: 0.5666666666666668Average of max per entry across top 5 scores: 0.6000000000000001Average of max per entry across top 8 scores: 0.6000000000000001Average of max per entry across top 9999 scores: 0.6000000000000001Bootstrapped 1 full traces after 2 examples in round 0.Average Metric: 25.666666666666668 / 50 (51.3%)Score: 51.33 for set: [16]Scores so far: [44.67, 44.67, 49.33, 51.33, 52.67, 51.33]Best score: 52.67Average of max per entry across top 1 scores: 0.5266666666666667Average of max per entry across top 2 scores: 0.56Average of max per entry across top 3 scores: 0.6000000000000001Average of max per entry across top 5 scores: 0.6133333333333334Average of max per entry across top 8 scores: 0.6133333333333334Average of max per entry across top 9999 scores: 0.61333333333333346 candidate programs found. ``` ``` Average Metric: 22.33333333333334 / 50 (44.7): 100%|█████| 50/50 [00:26<00:00, 1.87it/s]/Users/harrisonchase/.pyenv/versions/3.11.1/envs/langchain-3-11/lib/python3.11/site-packages/dspy/evaluate/evaluate.py:126: FutureWarning: DataFrame.applymap has been deprecated. Use DataFrame.map instead. df = df.applymap(truncate_cell)Average Metric: 22.33333333333334 / 50 (44.7): 100%|█████| 50/50 [00:00<00:00, 79.51it/s]/Users/harrisonchase/.pyenv/versions/3.11.1/envs/langchain-3-11/lib/python3.11/site-packages/dspy/evaluate/evaluate.py:126: FutureWarning: DataFrame.applymap has been deprecated. Use DataFrame.map instead. df = df.applymap(truncate_cell) 4%|██ | 8/200 [00:33<13:21, 4.18s/it]Average Metric: 24.666666666666668 / 50 (49.3): 100%|████| 50/50 [00:28<00:00, 1.77it/s]/Users/harrisonchase/.pyenv/versions/3.11.1/envs/langchain-3-11/lib/python3.11/site-packages/dspy/evaluate/evaluate.py:126: FutureWarning: DataFrame.applymap has been deprecated. Use DataFrame.map instead. df = df.applymap(truncate_cell) 6%|███ | 12/200 [00:31<08:16, 2.64s/it]Average Metric: 25.66666666666667 / 50 (51.3): 100%|█████| 50/50 [00:25<00:00, 1.92it/s]/Users/harrisonchase/.pyenv/versions/3.11.1/envs/langchain-3-11/lib/python3.11/site-packages/dspy/evaluate/evaluate.py:126: FutureWarning: DataFrame.applymap has been deprecated. Use DataFrame.map instead. df = df.applymap(truncate_cell) 0%|▎ | 1/200 [00:02<08:37, 2.60s/it]Average Metric: 26.33333333333334 / 50 (52.7): 100%|█████| 50/50 [00:23<00:00, 2.11it/s]/Users/harrisonchase/.pyenv/versions/3.11.1/envs/langchain-3-11/lib/python3.11/site-packages/dspy/evaluate/evaluate.py:126: FutureWarning: DataFrame.applymap has been deprecated. Use DataFrame.map instead. df = df.applymap(truncate_cell) 0%|▎ | 1/200 [00:02<07:11, 2.17s/it]Average Metric: 25.666666666666668 / 50 (51.3): 100%|████| 50/50 [00:21<00:00, 2.29it/s]/Users/harrisonchase/.pyenv/versions/3.11.1/envs/langchain-3-11/lib/python3.11/site-packages/dspy/evaluate/evaluate.py:126: FutureWarning: DataFrame.applymap has been deprecated. Use DataFrame.map instead. df = df.applymap(truncate_cell) ``` ## Evaluating the optimized chain[​](#evaluating-the-optimized-chain "Direct link to Evaluating the optimized chain") Well, how good is this? Let’s do some proper evals! ``` evaluate(optimized_chain) ``` ``` Average Metric: 74.66666666666666 / 150 (49.8): 100%|██| 150/150 [00:54<00:00, 2.74it/s]/Users/harrisonchase/.pyenv/versions/3.11.1/envs/langchain-3-11/lib/python3.11/site-packages/dspy/evaluate/evaluate.py:126: FutureWarning: DataFrame.applymap has been deprecated. Use DataFrame.map instead. df = df.applymap(truncate_cell) ``` ``` Average Metric: 74.66666666666666 / 150 (49.8%) ``` | | question | answer | gold\_titles | output | tweet\_response | metric | | --- | --- | --- | --- | --- | --- | --- | | 0 | Who was a producer who produced albums for both rock bands Juke Karten and Thirty Seconds to Mars? | Brian Virtue | {'Thirty Seconds to Mars', 'Levolution (album)'} | Brian Virtue, known for his work with Jane's Addiction and Velvet Revolver, produced albums for both Juke Kartel and Thirty Seconds to Mars. #BrianVirtue #Producer... | Brian Virtue, known for his work with Jane's Addiction and Velvet Revolver, produced albums for both Juke Kartel and Thirty Seconds to Mars. #BrianVirtue #Producer... | 1.0 | | 1 | Are both the University of Chicago and Syracuse University public universities? | no | {'Syracuse University', 'University of Chicago'} | No, only Northeastern Illinois University is a public state university. Syracuse University is a private research university. #University #PublicPrivate #HigherEd | No, only Northeastern Illinois University is a public state university. Syracuse University is a private research university. #University #PublicPrivate #HigherEd | 0.0 | | 2 | In what region was Eddy Mazzoleni born? | Lombardy, northern Italy | {'Eddy Mazzoleni', 'Bergamo'} | Eddy Mazzoleni, the Italian professional road cyclist, was born in Bergamo, Italy. #EddyMazzoleni #Cycling #Italy | Eddy Mazzoleni, the Italian professional road cyclist, was born in Bergamo, Italy. #EddyMazzoleni #Cycling #Italy | 0.0 | | 3 | Who edited the 1990 American romantic comedy film directed by Garry Marshall? | Raja Raymond Gosnell | {'Raja Gosnell', 'Pretty Woman'} | J. F. Lawton wrote the screenplay for Pretty Woman, the 1990 romantic comedy directed by Garry Marshall. #PrettyWoman #GarryMarshall #RomanticComedy | J. F. Lawton wrote the screenplay for Pretty Woman, the 1990 romantic comedy directed by Garry Marshall. #PrettyWoman #GarryMarshall #RomanticComedy | 0.0 | | 4 | Burrs Country Park railway station is what stop on the railway line that runs between Heywood and Rawtenstall | seventh | {'Burrs Country Park railway station', 'East Lancashire Railway'} | Burrs Country Park railway station is the seventh stop on the East Lancashire Railway, which runs between Heywood and Rawtenstall. #EastLancashireRailway #BurrsCountryPark #RailwayStation | Burrs Country Park railway station is the seventh stop on the East Lancashire Railway, which runs between Heywood and Rawtenstall. #EastLancashireRailway #BurrsCountryPark #RailwayStation | 1.0 | ... 145 more rows not displayed ... Alright! We’ve improved our chain from 42% to nearly 50%! ## Inspect the optimized chain[​](#inspect-the-optimized-chain "Direct link to Inspect the optimized chain") So what actually happened to improve this? We can take a look at this by looking at the optimized chain. We can do this in two ways ### Look at the prompt used[​](#look-at-the-prompt-used "Direct link to Look at the prompt used") We can look at what prompt was actually used. We can do this by looking at `dspy.settings`. ``` prompt_used, output = dspy.settings.langchain_history[-1] ``` ``` Essential Instructions: Respond to the provided question based on the given context in the style of a tweet, ensuring the response is concise and within the character limit of a tweet (up to 280 characters).---Follow the following format.Context: ${context}Question: ${question}Tweet Response: ${tweet_response}---Context:[1] «Brutus (Funny Car) | Brutus is a pioneering funny car driven by Jim Liberman and prepared by crew chief Lew Arrington in the middle 1960s.»[2] «USS Brutus (AC-15) | USS "Brutus", formerly the steamer "Peter Jebsen", was a collier in the United States Navy. She was built in 1894 at South Shields-on-Tyne, England, by John Readhead & Sons and was acquired by the U.S. Navy early in 1898 from L. F. Chapman & Company. She was renamed "Brutus" and commissioned at the Mare Island Navy Yard on 27 May 1898, with Lieutenant Vincendon L. Cottman, commanding officer and Lieutenant Randolph H. Miner, executive officer.»[3] «Brutus Beefcake | Ed Leslie is an American semi-retired professional wrestler, best known for his work in the World Wrestling Federation (WWF) under the ring name Brutus "The Barber" Beefcake. He later worked for World Championship Wrestling (WCW) under a variety of names.»[4] «Brutus Hamilton | Brutus Kerr Hamilton (July 19, 1900 – December 28, 1970) was an American track and field athlete, coach and athletics administrator.»[5] «Big Brutus | Big Brutus is the nickname of the Bucyrus-Erie model 1850B electric shovel, which was the second largest of its type in operation in the 1960s and 1970s. Big Brutus is the centerpiece of a mining museum in West Mineral, Kansas where it was used in coal strip mining operations. The shovel was designed to dig from 20 to in relatively shallow coal seams.»Question: What is the nickname for this United States drag racer who drove Brutus?Tweet Response: Jim Liberman, also known as "Jungle Jim", drove the pioneering funny car Brutus in the 1960s. #Brutus #FunnyCar #DragRacing---Context:[1] «Philip Markoff | Philip Haynes Markoff (February 12, 1986 – August 15, 2010) was an American medical student who was charged with the armed robbery and murder of Julissa Brisman in a Boston, Massachusetts, hotel on April 14, 2009, and two other armed robberies.»[2] «Antonia Brenner | Antonia Brenner, better known as Mother Antonia (Spanish: Madre Antonia ), (December 1, 1926 – October 17, 2013) was an American Roman Catholic Religious Sister and activist who chose to reside and care for inmates at the notorious maximum-security La Mesa Prison in Tijuana, Mexico. As a result of her work, she founded a new religious institute called the Eudist Servants of the 11th Hour.»[3] «Luzira Maximum Security Prison | Luzira Maximum Security Prison is a maximum security prison for both men and women in Uganda. As at July 2016, it is the only maximum security prison in the country and houses Uganda's death row inmates.»[4] «Pleasant Valley State Prison | Pleasant Valley State Prison (PVSP) is a 640 acres minimum-to-maximum security state prison in Coalinga, Fresno County, California. The facility has housed convicted murderers Sirhan Sirhan, Erik Menendez, X-Raided, and Hans Reiser, among others.»[5] «Jon-Adrian Velazquez | Jon-Adrian Velazquez is an inmate in the maximum security Sing-Sing prison in New York who is serving a 25-year sentence after being convicted of the 1998 murder of a retired police officer. His case garnered considerable attention from the media ten years after his conviction, due to a visit and support from Martin Sheen and a long-term investigation by Dateline NBC producer Dan Slepian.»Question: Which maximum security jail housed the killer of Julissa brisman?Tweet Response: ``` ### Look at the demos[​](#look-at-the-demos "Direct link to Look at the demos") The way this was optimized was that we collected examples (or “demos”) to put in the prompt. We can inspect the optmized\_chain to get a sense for what those are. ``` demos = [ eg for eg in optimized_chain.modules[0].demos if hasattr(eg, "augmented") and eg.augmented] ``` ``` [Example({'augmented': True, 'question': 'What is the nickname for this United States drag racer who drove Brutus?', 'context': ['Brutus (Funny Car) | Brutus is a pioneering funny car driven by Jim Liberman and prepared by crew chief Lew Arrington in the middle 1960s.', 'USS Brutus (AC-15) | USS "Brutus", formerly the steamer "Peter Jebsen", was a collier in the United States Navy. She was built in 1894 at South Shields-on-Tyne, England, by John Readhead & Sons and was acquired by the U.S. Navy early in 1898 from L. F. Chapman & Company. She was renamed "Brutus" and commissioned at the Mare Island Navy Yard on 27 May 1898, with Lieutenant Vincendon L. Cottman, commanding officer and Lieutenant Randolph H. Miner, executive officer.', 'Brutus Beefcake | Ed Leslie is an American semi-retired professional wrestler, best known for his work in the World Wrestling Federation (WWF) under the ring name Brutus "The Barber" Beefcake. He later worked for World Championship Wrestling (WCW) under a variety of names.', 'Brutus Hamilton | Brutus Kerr Hamilton (July 19, 1900 – December 28, 1970) was an American track and field athlete, coach and athletics administrator.', 'Big Brutus | Big Brutus is the nickname of the Bucyrus-Erie model 1850B electric shovel, which was the second largest of its type in operation in the 1960s and 1970s. Big Brutus is the centerpiece of a mining museum in West Mineral, Kansas where it was used in coal strip mining operations. The shovel was designed to dig from 20 to in relatively shallow coal seams.'], 'tweet_response': ' Jim Liberman, also known as "Jungle Jim", drove the pioneering funny car Brutus in the 1960s. #Brutus #FunnyCar #DragRacing'}) (input_keys=None)] ```

DSPy DSPy is a fantastic framework for LLMs that introduces an automatic compiler that teaches LMs how to conduct the declarative steps in your program. Specifically, the DSPy compiler will internally trace your program and then craft high-quality prompts for large LMs (or train automatic finetunes for small LMs) to teach them the steps of your task. Thanks to Omar Khattab we have an integration! It works with any LCEL chains with some minor modifications. This short tutorial demonstrates how this proof-of-concept feature works. This will not give you the full power of DSPy or LangChain yet, but we will expand it if there’s high demand. Note: this was slightly modified from the original example Omar wrote for DSPy. If you are interested in LangChain \<> DSPy but coming from the DSPy side, I’d recommend checking that out. You can find that here. Let’s take a look at an example. In this example we will make a simple RAG pipeline. We will use DSPy to “compile” our program and learn an optimized prompt. Install dependencies​ !pip install -U dspy-ai !pip install -U openai jinja2 !pip install -U langchain langchain-community langchain-openai langchain-core Setup​ We will be using OpenAI, so we should set an API key import getpass import os os.environ["OPENAI_API_KEY"] = getpass.getpass() We can now set up our retriever. For our retriever we will use a ColBERT retriever through DSPy, though this will work with any retriever. import dspy colbertv2 = dspy.ColBERTv2(url="http://20.102.90.50:2017/wiki17_abstracts") from langchain.cache import SQLiteCache from langchain.globals import set_llm_cache from langchain_openai import OpenAI set_llm_cache(SQLiteCache(database_path="cache.db")) llm = OpenAI(model_name="gpt-3.5-turbo-instruct", temperature=0) def retrieve(inputs): return [doc["text"] for doc in colbertv2(inputs["question"], k=5)] [{'text': 'Cycling | Cycling, also called bicycling or biking, is the use of bicycles for transport, recreation, exercise or sport. Persons engaged in cycling are referred to as "cyclists", "bikers", or less commonly, as "bicyclists". Apart from two-wheeled bicycles, "cycling" also includes the riding of unicycles, tricycles, quadracycles, recumbent and similar human-powered vehicles (HPVs).', 'pid': 2201868, 'rank': 1, 'score': 27.078739166259766, 'prob': 0.3544841299722533, 'long_text': 'Cycling | Cycling, also called bicycling or biking, is the use of bicycles for transport, recreation, exercise or sport. Persons engaged in cycling are referred to as "cyclists", "bikers", or less commonly, as "bicyclists". Apart from two-wheeled bicycles, "cycling" also includes the riding of unicycles, tricycles, quadracycles, recumbent and similar human-powered vehicles (HPVs).'}, {'text': 'Cycling (ice hockey) | In ice hockey, cycling is an offensive strategy that moves the puck along the boards in the offensive zone to create a scoring chance by making defenders tired or moving them out of position.', 'pid': 312153, 'rank': 2, 'score': 26.109302520751953, 'prob': 0.13445464524590262, 'long_text': 'Cycling (ice hockey) | In ice hockey, cycling is an offensive strategy that moves the puck along the boards in the offensive zone to create a scoring chance by making defenders tired or moving them out of position.'}, {'text': 'Bicycle | A bicycle, also called a cycle or bike, is a human-powered, pedal-driven, single-track vehicle, having two wheels attached to a frame, one behind the other. A is called a cyclist, or bicyclist.', 'pid': 2197695, 'rank': 3, 'score': 25.849220275878906, 'prob': 0.10366294133944996, 'long_text': 'Bicycle | A bicycle, also called a cycle or bike, is a human-powered, pedal-driven, single-track vehicle, having two wheels attached to a frame, one behind the other. A is called a cyclist, or bicyclist.'}, {'text': 'USA Cycling | USA Cycling or USAC, based in Colorado Springs, Colorado, is the national governing body for bicycle racing in the United States. It covers the disciplines of road, track, mountain bike, cyclo-cross, and BMX across all ages and ability levels. In 2015, USAC had a membership of 61,631 individual members.', 'pid': 3821927, 'rank': 4, 'score': 25.61395263671875, 'prob': 0.08193096873942958, 'long_text': 'USA Cycling | USA Cycling or USAC, based in Colorado Springs, Colorado, is the national governing body for bicycle racing in the United States. It covers the disciplines of road, track, mountain bike, cyclo-cross, and BMX across all ages and ability levels. In 2015, USAC had a membership of 61,631 individual members.'}, {'text': 'Vehicular cycling | Vehicular cycling (also known as bicycle driving) is the practice of riding bicycles on roads in a manner that is in accordance with the principles for driving in traffic.', 'pid': 3058888, 'rank': 5, 'score': 25.35515785217285, 'prob': 0.06324918635213703, 'long_text': 'Vehicular cycling | Vehicular cycling (also known as bicycle driving) is the practice of riding bicycles on roads in a manner that is in accordance with the principles for driving in traffic.'}, {'text': 'Road cycling | Road cycling is the most widespread form of cycling. It includes recreational, racing, and utility cycling. Road cyclists are generally expected to obey the same rules and laws as other vehicle drivers or riders and may also be vehicular cyclists.', 'pid': 3392359, 'rank': 6, 'score': 25.274639129638672, 'prob': 0.058356079351563846, 'long_text': 'Road cycling | Road cycling is the most widespread form of cycling. It includes recreational, racing, and utility cycling. Road cyclists are generally expected to obey the same rules and laws as other vehicle drivers or riders and may also be vehicular cyclists.'}, {'text': 'Cycling South Africa | Cycling South Africa or Cycling SA is the national governing body of cycle racing in South Africa. Cycling SA is a member of the "Confédération Africaine de Cyclisme" and the "Union Cycliste Internationale" (UCI). It is affiliated to the South African Sports Confederation and Olympic Committee (SASCOC) as well as the Department of Sport and Recreation SA. Cycling South Africa regulates the five major disciplines within the sport, both amateur and professional, which include: road cycling, mountain biking, BMX biking, track cycling and para-cycling.', 'pid': 2508026, 'rank': 7, 'score': 25.24260711669922, 'prob': 0.05651643767006817, 'long_text': 'Cycling South Africa | Cycling South Africa or Cycling SA is the national governing body of cycle racing in South Africa. Cycling SA is a member of the "Confédération Africaine de Cyclisme" and the "Union Cycliste Internationale" (UCI). It is affiliated to the South African Sports Confederation and Olympic Committee (SASCOC) as well as the Department of Sport and Recreation SA. Cycling South Africa regulates the five major disciplines within the sport, both amateur and professional, which include: road cycling, mountain biking, BMX biking, track cycling and para-cycling.'}, {'text': 'Cycle sport | Cycle sport is competitive physical activity using bicycles. There are several categories of bicycle racing including road bicycle racing, time trialling, cyclo-cross, mountain bike racing, track cycling, BMX, and cycle speedway. Non-racing cycling sports include artistic cycling, cycle polo, freestyle BMX and mountain bike trials. The Union Cycliste Internationale (UCI) is the world governing body for cycling and international competitive cycling events. The International Human Powered Vehicle Association is the governing body for human-powered vehicles that imposes far fewer restrictions on their design than does the UCI. The UltraMarathon Cycling Association is the governing body for many ultra-distance cycling races.', 'pid': 3394121, 'rank': 8, 'score': 25.170495986938477, 'prob': 0.05258444735141742, 'long_text': 'Cycle sport | Cycle sport is competitive physical activity using bicycles. There are several categories of bicycle racing including road bicycle racing, time trialling, cyclo-cross, mountain bike racing, track cycling, BMX, and cycle speedway. Non-racing cycling sports include artistic cycling, cycle polo, freestyle BMX and mountain bike trials. The Union Cycliste Internationale (UCI) is the world governing body for cycling and international competitive cycling events. The International Human Powered Vehicle Association is the governing body for human-powered vehicles that imposes far fewer restrictions on their design than does the UCI. The UltraMarathon Cycling Association is the governing body for many ultra-distance cycling races.'}, {'text': "Cycling UK | Cycling UK is the brand name of the Cyclists' Touring Club or CTC. It is a charitable membership organisation supporting cyclists and promoting bicycle use. Cycling UK is registered at Companies House (as “Cyclists’ Touring Club”), and covered by company law; it is the largest such organisation in the UK. It works at a national and local level to lobby for cyclists' needs and wants, provides services to members, and organises local groups for local activism and those interested in recreational cycling. The original Cyclists' Touring Club began in the nineteenth century with a focus on amateur road cycling but these days has a much broader sphere of interest encompassing everyday transport, commuting and many forms of recreational cycling. Prior to April 2016, Cycling UK operated under the brand CTC, the national cycling charity. As of January 2007, the organisation's president was the newsreader Jon Snow.", 'pid': 1841483, 'rank': 9, 'score': 25.166988372802734, 'prob': 0.05240032450529368, 'long_text': "Cycling UK | Cycling UK is the brand name of the Cyclists' Touring Club or CTC. It is a charitable membership organisation supporting cyclists and promoting bicycle use. Cycling UK is registered at Companies House (as “Cyclists’ Touring Club”), and covered by company law; it is the largest such organisation in the UK. It works at a national and local level to lobby for cyclists' needs and wants, provides services to members, and organises local groups for local activism and those interested in recreational cycling. The original Cyclists' Touring Club began in the nineteenth century with a focus on amateur road cycling but these days has a much broader sphere of interest encompassing everyday transport, commuting and many forms of recreational cycling. Prior to April 2016, Cycling UK operated under the brand CTC, the national cycling charity. As of January 2007, the organisation's president was the newsreader Jon Snow."}, {'text': 'Cycling in the Netherlands | Cycling is a ubiquitous mode of transport in the Netherlands, with 36% of the people listing the bicycle as their most frequent mode of transport on a typical day as opposed to the car by 45% and public transport by 11%. Cycling has a modal share of 27% of all trips (urban and rural) nationwide. In cities this is even higher, such as Amsterdam which has 38%, though the smaller Dutch cities well exceed that: for instance Zwolle (pop. ~123,000) has 46% and the university town of Groningen (pop. ~198,000) has 31%. This high modal share for bicycle travel is enabled by excellent cycling infrastructure such as cycle paths, cycle tracks, protected intersections, ubiquitous bicycle parking and by making cycling routes shorter, quicker and more direct than car routes.', 'pid': 1196118, 'rank': 10, 'score': 24.954299926757812, 'prob': 0.0423608394724844, 'long_text': 'Cycling in the Netherlands | Cycling is a ubiquitous mode of transport in the Netherlands, with 36% of the people listing the bicycle as their most frequent mode of transport on a typical day as opposed to the car by 45% and public transport by 11%. Cycling has a modal share of 27% of all trips (urban and rural) nationwide. In cities this is even higher, such as Amsterdam which has 38%, though the smaller Dutch cities well exceed that: for instance Zwolle (pop. ~123,000) has 46% and the university town of Groningen (pop. ~198,000) has 31%. This high modal share for bicycle travel is enabled by excellent cycling infrastructure such as cycle paths, cycle tracks, protected intersections, ubiquitous bicycle parking and by making cycling routes shorter, quicker and more direct than car routes.'}] Normal LCEL​ First, let’s create a simple RAG pipeline with LCEL like we would normally. For illustration, let’s tackle the following task. Task: Build a RAG system for generating informative tweets. Input: A factual question, which may be fairly complex. Output: An engaging tweet that correctly answers the question from the retrieved info. Let’s use LangChain’s expression language (LCEL) to illustrate this. Any prompt here will do, we will optimize the final prompt with DSPy. Considering that, let’s just keep it to the barebones: Given {context}, answer the question {question} as a tweet. # From LangChain, import standard modules for prompting. from langchain_core.output_parsers import StrOutputParser from langchain_core.prompts import PromptTemplate from langchain_core.runnables import RunnablePassthrough # Just a simple prompt for this task. It's fine if it's complex too. prompt = PromptTemplate.from_template( "Given {context}, answer the question `{question}` as a tweet." ) # This is how you'd normally build a chain with LCEL. This chain does retrieval then generation (RAG). vanilla_chain = ( RunnablePassthrough.assign(context=retrieve) | prompt | llm | StrOutputParser() ) LCEL \<> DSPy​ In order to use LangChain with DSPy, you need to make two minor modifications LangChainPredict You need to change from doing prompt | llm to using LangChainPredict(prompt, llm) from dspy. This is a wrapper which will bind your prompt and llm together so you can optimize them LangChainModule This is a wrapper which wraps your final LCEL chain so that DSPy can optimize the whole thing # From DSPy, import the modules that know how to interact with LangChain LCEL. from dspy.predict.langchain import LangChainModule, LangChainPredict # This is how to wrap it so it behaves like a DSPy program. # Just Replace every pattern like `prompt | llm` with `LangChainPredict(prompt, llm)`. zeroshot_chain = ( RunnablePassthrough.assign(context=retrieve) | LangChainPredict(prompt, llm) | StrOutputParser() ) # Now we wrap it in LangChainModule zeroshot_chain = LangChainModule( zeroshot_chain ) # then wrap the chain in a DSPy module. Trying the Module​ After this, we can use it as both a LangChain runnable and a DSPy module! question = "In what region was Eddy Mazzoleni born?" zeroshot_chain.invoke({"question": question}) ' Eddy Mazzoleni, born in Bergamo, Italy, is a professional road cyclist who rode for UCI ProTour Astana Team. #cyclist #Italy' Ah that sounds about right! (It’s technically not perfect: we asked for the region not the city. We can do better below.) Inspecting questions and answers manually is very important to get a sense of your system. However, a good system designer always looks to iteratively benchmark their work to quantify progress! To do this, we need two things: the metric we want to maximize and a (tiny) dataset of examples for our system. Are there pre-defined metrics for good tweets? Should I label 100,000 tweets by hand? Probably not. We can easily do something reasonable, though, until you start getting data in production! Load Data​ In order to compile our chain, we need a dataset to work with. This dataset just needs to be raw inputs and outputs. For our purposes, we will use HotPotQA dataset Note: Notice that our dataset doesn’t actually include any tweets! It only has questions and answers. That’s OK, our metric will take care of evaluating outputs in tweet form. import dspy from dspy.datasets import HotPotQA # Load the dataset. dataset = HotPotQA( train_seed=1, train_size=200, eval_seed=2023, dev_size=200, test_size=0, keep_details=True, ) # Tell DSPy that the 'question' field is the input. Any other fields are labels and/or metadata. trainset = [x.without("id", "type").with_inputs("question") for x in dataset.train] devset = [x.without("id", "type").with_inputs("question") for x in dataset.dev] valset, devset = devset[:50], devset[50:] /Users/harrisonchase/.pyenv/versions/3.11.1/envs/langchain-3-11/lib/python3.11/site-packages/datasets/table.py:1421: FutureWarning: promote has been superseded by mode='default'. table = cls._concat_blocks(blocks, axis=0) Define a metic​ We now need to define a metric. This will be used to determine which runs were successful and we can learn from. Here we will use DSPy’s metrics, though you can write your own. # Define the signature for autoamtic assessments. class Assess(dspy.Signature): """Assess the quality of a tweet along the specified dimension.""" context = dspy.InputField(desc="ignore if N/A") assessed_text = dspy.InputField() assessment_question = dspy.InputField() assessment_answer = dspy.OutputField(desc="Yes or No") gpt4T = dspy.OpenAI(model="gpt-4-1106-preview", max_tokens=1000, model_type="chat") METRIC = None def metric(gold, pred, trace=None): question, answer, tweet = gold.question, gold.answer, pred.output context = colbertv2(question, k=5) engaging = "Does the assessed text make for a self-contained, engaging tweet?" faithful = "Is the assessed text grounded in the context? Say no if it includes significant facts not in the context." correct = ( f"The text above is should answer `{question}`. The gold answer is `{answer}`." ) correct = f"{correct} Does the assessed text above contain the gold answer?" with dspy.context(lm=gpt4T): faithful = dspy.Predict(Assess)( context=context, assessed_text=tweet, assessment_question=faithful ) correct = dspy.Predict(Assess)( context="N/A", assessed_text=tweet, assessment_question=correct ) engaging = dspy.Predict(Assess)( context="N/A", assessed_text=tweet, assessment_question=engaging ) correct, engaging, faithful = [ m.assessment_answer.split()[0].lower() == "yes" for m in [correct, engaging, faithful] ] score = (correct + engaging + faithful) if correct and (len(tweet) <= 280) else 0 if METRIC is not None: if METRIC == "correct": return correct if METRIC == "engaging": return engaging if METRIC == "faithful": return faithful if trace is not None: return score >= 3 return score / 3.0 Evaluate Baseline​ Okay, let’s evaluate the unoptimized “zero-shot” version of our chain, converted from our LangChain LCEL object. from dspy.evaluate.evaluate import Evaluate evaluate = Evaluate( metric=metric, devset=devset, num_threads=8, display_progress=True, display_table=5 ) evaluate(zeroshot_chain) Average Metric: 62.99999999999998 / 150 (42.0): 100%|██| 150/150 [01:14<00:00, 2.02it/s] /Users/harrisonchase/.pyenv/versions/3.11.1/envs/langchain-3-11/lib/python3.11/site-packages/dspy/evaluate/evaluate.py:126: FutureWarning: DataFrame.applymap has been deprecated. Use DataFrame.map instead. df = df.applymap(truncate_cell) Average Metric: 62.99999999999998 / 150 (42.0%) questionanswergold_titlesoutputtweet_responsemetric 0 Who was a producer who produced albums for both rock bands Juke Karten and Thirty Seconds to Mars? Brian Virtue {'Thirty Seconds to Mars', 'Levolution (album)'} Brian Virtue, who has worked with bands like Jane's Addiction and Velvet Revolver, produced albums for both Juke Kartel and Thirty Seconds to Mars. #BrianVirtue... Brian Virtue, who has worked with bands like Jane's Addiction and Velvet Revolver, produced albums for both Juke Kartel and Thirty Seconds to Mars. #BrianVirtue... 1.0 1 Are both the University of Chicago and Syracuse University public universities? no {'Syracuse University', 'University of Chicago'} No, only Syracuse University is a public university. The University of Chicago is a private research university. #university #publicvsprivate No, only Syracuse University is a public university. The University of Chicago is a private research university. #university #publicvsprivate 0.3333333333333333 2 In what region was Eddy Mazzoleni born? Lombardy, northern Italy {'Eddy Mazzoleni', 'Bergamo'} Eddy Mazzoleni, born in Bergamo, Italy, is a professional road cyclist who rode for UCI ProTour Astana Team. #cyclist #Italy Eddy Mazzoleni, born in Bergamo, Italy, is a professional road cyclist who rode for UCI ProTour Astana Team. #cyclist #Italy 0.0 3 Who edited the 1990 American romantic comedy film directed by Garry Marshall? Raja Raymond Gosnell {'Raja Gosnell', 'Pretty Woman'} J. F. Lawton wrote the screenplay for Pretty Woman, the 1990 American romantic comedy film directed by Garry Marshall. #PrettyWoman #GarryMarshall #JFLawton J. F. Lawton wrote the screenplay for Pretty Woman, the 1990 American romantic comedy film directed by Garry Marshall. #PrettyWoman #GarryMarshall #JFLawton 0.0 4 Burrs Country Park railway station is what stop on the railway line that runs between Heywood and Rawtenstall seventh {'Burrs Country Park railway station', 'East Lancashire Railway'} Burrs Country Park railway station is the seventh stop on the East Lancashire Railway line that runs between Heywood and Rawtenstall. Burrs Country Park railway station is the seventh stop on the East Lancashire Railway line that runs between Heywood and Rawtenstall. 1.0 ... 145 more rows not displayed ... Okay, cool. Our zeroshot_chain gets about 42.00% on the 150 questions from the devset. The table above shows some examples. For instance: Question: Who was a producer who produced albums for both rock bands Juke Karten and Thirty Seconds to Mars? Tweet: Brian Virtue, who has worked with bands like Jane’s Addiction and Velvet Revolver, produced albums for both Juke Kartel and Thirty Seconds to Mars, showcasing… [truncated] Metric: 1.0 (A tweet that is correct, faithful, and engaging!*) footnote: * At least according to our metric, which is just a DSPy program, so it too can be optimized if you’d like! Topic for another notebook, though. Optimize​ Now, let’s optimize performance from dspy.teleprompt import BootstrapFewShotWithRandomSearch # Set up the optimizer. We'll use very minimal hyperparameters for this example. # Just do random search with ~3 attempts, and in each attempt, bootstrap <= 3 traces. optimizer = BootstrapFewShotWithRandomSearch( metric=metric, max_bootstrapped_demos=3, num_candidate_programs=3 ) # Now use the optimizer to *compile* the chain. This could take 5-10 minutes, unless it's cached. optimized_chain = optimizer.compile(zeroshot_chain, trainset=trainset, valset=valset) Going to sample between 1 and 3 traces per predictor. Will attempt to train 3 candidate sets. Average Metric: 22.33333333333334 / 50 (44.7%) Score: 44.67 for set: [0] New best score: 44.67 for seed -3 Scores so far: [44.67] Best score: 44.67 Average Metric: 22.33333333333334 / 50 (44.7%) Score: 44.67 for set: [16] Scores so far: [44.67, 44.67] Best score: 44.67 Bootstrapped 3 full traces after 9 examples in round 0. Average Metric: 24.666666666666668 / 50 (49.3%) Score: 49.33 for set: [16] New best score: 49.33 for seed -1 Scores so far: [44.67, 44.67, 49.33] Best score: 49.33 Average of max per entry across top 1 scores: 0.49333333333333335 Average of max per entry across top 2 scores: 0.5533333333333335 Average of max per entry across top 3 scores: 0.5533333333333335 Average of max per entry across top 5 scores: 0.5533333333333335 Average of max per entry across top 8 scores: 0.5533333333333335 Average of max per entry across top 9999 scores: 0.5533333333333335 Bootstrapped 2 full traces after 13 examples in round 0. Average Metric: 25.66666666666667 / 50 (51.3%) Score: 51.33 for set: [16] New best score: 51.33 for seed 0 Scores so far: [44.67, 44.67, 49.33, 51.33] Best score: 51.33 Average of max per entry across top 1 scores: 0.5133333333333334 Average of max per entry across top 2 scores: 0.5666666666666668 Average of max per entry across top 3 scores: 0.6000000000000001 Average of max per entry across top 5 scores: 0.6000000000000001 Average of max per entry across top 8 scores: 0.6000000000000001 Average of max per entry across top 9999 scores: 0.6000000000000001 Bootstrapped 1 full traces after 2 examples in round 0. Average Metric: 26.33333333333334 / 50 (52.7%) Score: 52.67 for set: [16] New best score: 52.67 for seed 1 Scores so far: [44.67, 44.67, 49.33, 51.33, 52.67] Best score: 52.67 Average of max per entry across top 1 scores: 0.5266666666666667 Average of max per entry across top 2 scores: 0.56 Average of max per entry across top 3 scores: 0.5666666666666668 Average of max per entry across top 5 scores: 0.6000000000000001 Average of max per entry across top 8 scores: 0.6000000000000001 Average of max per entry across top 9999 scores: 0.6000000000000001 Bootstrapped 1 full traces after 2 examples in round 0. Average Metric: 25.666666666666668 / 50 (51.3%) Score: 51.33 for set: [16] Scores so far: [44.67, 44.67, 49.33, 51.33, 52.67, 51.33] Best score: 52.67 Average of max per entry across top 1 scores: 0.5266666666666667 Average of max per entry across top 2 scores: 0.56 Average of max per entry across top 3 scores: 0.6000000000000001 Average of max per entry across top 5 scores: 0.6133333333333334 Average of max per entry across top 8 scores: 0.6133333333333334 Average of max per entry across top 9999 scores: 0.6133333333333334 6 candidate programs found. Average Metric: 22.33333333333334 / 50 (44.7): 100%|█████| 50/50 [00:26<00:00, 1.87it/s] /Users/harrisonchase/.pyenv/versions/3.11.1/envs/langchain-3-11/lib/python3.11/site-packages/dspy/evaluate/evaluate.py:126: FutureWarning: DataFrame.applymap has been deprecated. Use DataFrame.map instead. df = df.applymap(truncate_cell) Average Metric: 22.33333333333334 / 50 (44.7): 100%|█████| 50/50 [00:00<00:00, 79.51it/s] /Users/harrisonchase/.pyenv/versions/3.11.1/envs/langchain-3-11/lib/python3.11/site-packages/dspy/evaluate/evaluate.py:126: FutureWarning: DataFrame.applymap has been deprecated. Use DataFrame.map instead. df = df.applymap(truncate_cell) 4%|██ | 8/200 [00:33<13:21, 4.18s/it] Average Metric: 24.666666666666668 / 50 (49.3): 100%|████| 50/50 [00:28<00:00, 1.77it/s] /Users/harrisonchase/.pyenv/versions/3.11.1/envs/langchain-3-11/lib/python3.11/site-packages/dspy/evaluate/evaluate.py:126: FutureWarning: DataFrame.applymap has been deprecated. Use DataFrame.map instead. df = df.applymap(truncate_cell) 6%|███ | 12/200 [00:31<08:16, 2.64s/it] Average Metric: 25.66666666666667 / 50 (51.3): 100%|█████| 50/50 [00:25<00:00, 1.92it/s] /Users/harrisonchase/.pyenv/versions/3.11.1/envs/langchain-3-11/lib/python3.11/site-packages/dspy/evaluate/evaluate.py:126: FutureWarning: DataFrame.applymap has been deprecated. Use DataFrame.map instead. df = df.applymap(truncate_cell) 0%|▎ | 1/200 [00:02<08:37, 2.60s/it] Average Metric: 26.33333333333334 / 50 (52.7): 100%|█████| 50/50 [00:23<00:00, 2.11it/s] /Users/harrisonchase/.pyenv/versions/3.11.1/envs/langchain-3-11/lib/python3.11/site-packages/dspy/evaluate/evaluate.py:126: FutureWarning: DataFrame.applymap has been deprecated. Use DataFrame.map instead. df = df.applymap(truncate_cell) 0%|▎ | 1/200 [00:02<07:11, 2.17s/it] Average Metric: 25.666666666666668 / 50 (51.3): 100%|████| 50/50 [00:21<00:00, 2.29it/s] /Users/harrisonchase/.pyenv/versions/3.11.1/envs/langchain-3-11/lib/python3.11/site-packages/dspy/evaluate/evaluate.py:126: FutureWarning: DataFrame.applymap has been deprecated. Use DataFrame.map instead. df = df.applymap(truncate_cell) Evaluating the optimized chain​ Well, how good is this? Let’s do some proper evals! evaluate(optimized_chain) Average Metric: 74.66666666666666 / 150 (49.8): 100%|██| 150/150 [00:54<00:00, 2.74it/s] /Users/harrisonchase/.pyenv/versions/3.11.1/envs/langchain-3-11/lib/python3.11/site-packages/dspy/evaluate/evaluate.py:126: FutureWarning: DataFrame.applymap has been deprecated. Use DataFrame.map instead. df = df.applymap(truncate_cell) Average Metric: 74.66666666666666 / 150 (49.8%) questionanswergold_titlesoutputtweet_responsemetric 0 Who was a producer who produced albums for both rock bands Juke Karten and Thirty Seconds to Mars? Brian Virtue {'Thirty Seconds to Mars', 'Levolution (album)'} Brian Virtue, known for his work with Jane's Addiction and Velvet Revolver, produced albums for both Juke Kartel and Thirty Seconds to Mars. #BrianVirtue #Producer... Brian Virtue, known for his work with Jane's Addiction and Velvet Revolver, produced albums for both Juke Kartel and Thirty Seconds to Mars. #BrianVirtue #Producer... 1.0 1 Are both the University of Chicago and Syracuse University public universities? no {'Syracuse University', 'University of Chicago'} No, only Northeastern Illinois University is a public state university. Syracuse University is a private research university. #University #PublicPrivate #HigherEd No, only Northeastern Illinois University is a public state university. Syracuse University is a private research university. #University #PublicPrivate #HigherEd 0.0 2 In what region was Eddy Mazzoleni born? Lombardy, northern Italy {'Eddy Mazzoleni', 'Bergamo'} Eddy Mazzoleni, the Italian professional road cyclist, was born in Bergamo, Italy. #EddyMazzoleni #Cycling #Italy Eddy Mazzoleni, the Italian professional road cyclist, was born in Bergamo, Italy. #EddyMazzoleni #Cycling #Italy 0.0 3 Who edited the 1990 American romantic comedy film directed by Garry Marshall? Raja Raymond Gosnell {'Raja Gosnell', 'Pretty Woman'} J. F. Lawton wrote the screenplay for Pretty Woman, the 1990 romantic comedy directed by Garry Marshall. #PrettyWoman #GarryMarshall #RomanticComedy J. F. Lawton wrote the screenplay for Pretty Woman, the 1990 romantic comedy directed by Garry Marshall. #PrettyWoman #GarryMarshall #RomanticComedy 0.0 4 Burrs Country Park railway station is what stop on the railway line that runs between Heywood and Rawtenstall seventh {'Burrs Country Park railway station', 'East Lancashire Railway'} Burrs Country Park railway station is the seventh stop on the East Lancashire Railway, which runs between Heywood and Rawtenstall. #EastLancashireRailway #BurrsCountryPark #RailwayStation Burrs Country Park railway station is the seventh stop on the East Lancashire Railway, which runs between Heywood and Rawtenstall. #EastLancashireRailway #BurrsCountryPark #RailwayStation 1.0 ... 145 more rows not displayed ... Alright! We’ve improved our chain from 42% to nearly 50%! Inspect the optimized chain​ So what actually happened to improve this? We can take a look at this by looking at the optimized chain. We can do this in two ways Look at the prompt used​ We can look at what prompt was actually used. We can do this by looking at dspy.settings. prompt_used, output = dspy.settings.langchain_history[-1] Essential Instructions: Respond to the provided question based on the given context in the style of a tweet, ensuring the response is concise and within the character limit of a tweet (up to 280 characters). --- Follow the following format. Context: ${context} Question: ${question} Tweet Response: ${tweet_response} --- Context: [1] «Brutus (Funny Car) | Brutus is a pioneering funny car driven by Jim Liberman and prepared by crew chief Lew Arrington in the middle 1960s.» [2] «USS Brutus (AC-15) | USS "Brutus", formerly the steamer "Peter Jebsen", was a collier in the United States Navy. She was built in 1894 at South Shields-on-Tyne, England, by John Readhead & Sons and was acquired by the U.S. Navy early in 1898 from L. F. Chapman & Company. She was renamed "Brutus" and commissioned at the Mare Island Navy Yard on 27 May 1898, with Lieutenant Vincendon L. Cottman, commanding officer and Lieutenant Randolph H. Miner, executive officer.» [3] «Brutus Beefcake | Ed Leslie is an American semi-retired professional wrestler, best known for his work in the World Wrestling Federation (WWF) under the ring name Brutus "The Barber" Beefcake. He later worked for World Championship Wrestling (WCW) under a variety of names.» [4] «Brutus Hamilton | Brutus Kerr Hamilton (July 19, 1900 – December 28, 1970) was an American track and field athlete, coach and athletics administrator.» [5] «Big Brutus | Big Brutus is the nickname of the Bucyrus-Erie model 1850B electric shovel, which was the second largest of its type in operation in the 1960s and 1970s. Big Brutus is the centerpiece of a mining museum in West Mineral, Kansas where it was used in coal strip mining operations. The shovel was designed to dig from 20 to in relatively shallow coal seams.» Question: What is the nickname for this United States drag racer who drove Brutus? Tweet Response: Jim Liberman, also known as "Jungle Jim", drove the pioneering funny car Brutus in the 1960s. #Brutus #FunnyCar #DragRacing --- Context: [1] «Philip Markoff | Philip Haynes Markoff (February 12, 1986 – August 15, 2010) was an American medical student who was charged with the armed robbery and murder of Julissa Brisman in a Boston, Massachusetts, hotel on April 14, 2009, and two other armed robberies.» [2] «Antonia Brenner | Antonia Brenner, better known as Mother Antonia (Spanish: Madre Antonia ), (December 1, 1926 – October 17, 2013) was an American Roman Catholic Religious Sister and activist who chose to reside and care for inmates at the notorious maximum-security La Mesa Prison in Tijuana, Mexico. As a result of her work, she founded a new religious institute called the Eudist Servants of the 11th Hour.» [3] «Luzira Maximum Security Prison | Luzira Maximum Security Prison is a maximum security prison for both men and women in Uganda. As at July 2016, it is the only maximum security prison in the country and houses Uganda's death row inmates.» [4] «Pleasant Valley State Prison | Pleasant Valley State Prison (PVSP) is a 640 acres minimum-to-maximum security state prison in Coalinga, Fresno County, California. The facility has housed convicted murderers Sirhan Sirhan, Erik Menendez, X-Raided, and Hans Reiser, among others.» [5] «Jon-Adrian Velazquez | Jon-Adrian Velazquez is an inmate in the maximum security Sing-Sing prison in New York who is serving a 25-year sentence after being convicted of the 1998 murder of a retired police officer. His case garnered considerable attention from the media ten years after his conviction, due to a visit and support from Martin Sheen and a long-term investigation by Dateline NBC producer Dan Slepian.» Question: Which maximum security jail housed the killer of Julissa brisman? Tweet Response: Look at the demos​ The way this was optimized was that we collected examples (or “demos”) to put in the prompt. We can inspect the optmized_chain to get a sense for what those are. demos = [ eg for eg in optimized_chain.modules[0].demos if hasattr(eg, "augmented") and eg.augmented ] [Example({'augmented': True, 'question': 'What is the nickname for this United States drag racer who drove Brutus?', 'context': ['Brutus (Funny Car) | Brutus is a pioneering funny car driven by Jim Liberman and prepared by crew chief Lew Arrington in the middle 1960s.', 'USS Brutus (AC-15) | USS "Brutus", formerly the steamer "Peter Jebsen", was a collier in the United States Navy. She was built in 1894 at South Shields-on-Tyne, England, by John Readhead & Sons and was acquired by the U.S. Navy early in 1898 from L. F. Chapman & Company. She was renamed "Brutus" and commissioned at the Mare Island Navy Yard on 27 May 1898, with Lieutenant Vincendon L. Cottman, commanding officer and Lieutenant Randolph H. Miner, executive officer.', 'Brutus Beefcake | Ed Leslie is an American semi-retired professional wrestler, best known for his work in the World Wrestling Federation (WWF) under the ring name Brutus "The Barber" Beefcake. He later worked for World Championship Wrestling (WCW) under a variety of names.', 'Brutus Hamilton | Brutus Kerr Hamilton (July 19, 1900 – December 28, 1970) was an American track and field athlete, coach and athletics administrator.', 'Big Brutus | Big Brutus is the nickname of the Bucyrus-Erie model 1850B electric shovel, which was the second largest of its type in operation in the 1960s and 1970s. Big Brutus is the centerpiece of a mining museum in West Mineral, Kansas where it was used in coal strip mining operations. The shovel was designed to dig from 20 to in relatively shallow coal seams.'], 'tweet_response': ' Jim Liberman, also known as "Jungle Jim", drove the pioneering funny car Brutus in the 1960s. #Brutus #FunnyCar #DragRacing'}) (input_keys=None)]

https://python.langchain.com/docs/integrations/providers/duckdb/

First, you need to install `duckdb` python package. ``` from langchain_community.document_loaders import DuckDBLoader ```

First, you need to install duckdb python package. from langchain_community.document_loaders import DuckDBLoader

https://python.langchain.com/docs/integrations/providers/ibm/

## 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[​](#installation-and-setup "Direct link to Installation and Setup") Install the integration package with ``` pip install -qU langchain-ibm ``` Get an IBM watsonx.ai api key and set it as an environment variable (`WATSONX_APIKEY`) ``` import osos.environ["WATSONX_APIKEY"] = "your IBM watsonx.ai api key" ``` ## LLMs[​](#llms "Direct link to LLMs") ### WatsonxLLM[​](#watsonxllm "Direct link to WatsonxLLM") See a [usage example](https://python.langchain.com/docs/integrations/llms/ibm_watsonx/). ``` from langchain_ibm import WatsonxLLM ``` ## Embedding Models[​](#embedding-models "Direct link to Embedding Models") ### WatsonxEmbeddings[​](#watsonxembeddings "Direct link to WatsonxEmbeddings") See a [usage example](https://python.langchain.com/docs/integrations/text_embedding/ibm_watsonx/). ``` from langchain_ibm import WatsonxEmbeddings ```

IBM The LangChain integrations related to IBM watsonx.ai platform. IBM® watsonx.ai™ AI studio is part of the IBM watsonx™ AI and data platform, bringing together new generative AI capabilities powered by 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 pip install -qU langchain-ibm Get an IBM watsonx.ai api key and set it as an environment variable (WATSONX_APIKEY) import os os.environ["WATSONX_APIKEY"] = "your IBM watsonx.ai api key" LLMs​ WatsonxLLM​ See a usage example. from langchain_ibm import WatsonxLLM Embedding Models​ WatsonxEmbeddings​ See a usage example. from langchain_ibm import WatsonxEmbeddings

https://python.langchain.com/docs/integrations/providers/ifixit/

## 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[​](#installation-and-setup "Direct link to Installation and Setup") There isn't any special setup for it. ## Document Loader[​](#document-loader "Direct link to Document Loader") See a [usage example](https://python.langchain.com/docs/integrations/document_loaders/ifixit/). ``` from langchain_community.document_loaders import IFixitLoader ```

iFixit iFixit 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. from langchain_community.document_loaders import IFixitLoader

https://python.langchain.com/docs/integrations/providers/exa_search/

Exa’s search integration exists in its own [partner package](https://pypi.org/project/langchain-exa/). You can install it with: ``` %pip install -qU langchain-exa ``` In order to use the package, you will also need to set the `EXA_API_KEY` environment variable to your Exa API key. You can use the [`ExaSearchRetriever`](https://python.langchain.com/docs/integrations/tools/exa_search/#using-exasearchretriever) in a standard retrieval pipeline. You can import it as follows

Exa’s search integration exists in its own partner package. You can install it with: %pip install -qU langchain-exa In order to use the package, you will also need to set the EXA_API_KEY environment variable to your Exa API key. You can use the ExaSearchRetriever in a standard retrieval pipeline. You can import it as follows

https://python.langchain.com/docs/integrations/providers/infinispanvs/

See [Get Started](https://infinispan.org/get-started/) to run an Infinispan server, you may want to disable authentication (not supported atm) ``` from langchain_community.vectorstores import InfinispanVS ```

See Get Started to run an Infinispan server, you may want to disable authentication (not supported atm) from langchain_community.vectorstores import InfinispanVS

https://python.langchain.com/docs/integrations/providers/edenai/

## 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[​](#installation-and-setup "Direct link to 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[​](#llms "Direct link to LLMs") See a [usage example](https://python.langchain.com/docs/integrations/llms/edenai/). ``` from langchain_community.llms import EdenAI ``` ## Chat models[​](#chat-models "Direct link to Chat models") See a [usage example](https://python.langchain.com/docs/integrations/chat/edenai/). ``` from langchain_community.chat_models.edenai import ChatEdenAI ``` ## Embedding models[​](#embedding-models "Direct link to Embedding models") See a [usage example](https://python.langchain.com/docs/integrations/text_embedding/edenai/). ``` from langchain_community.embeddings.edenai import EdenAiEmbeddings ``` 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](https://python.langchain.com/docs/integrations/tools/edenai_tools/). ``` from langchain_community.tools.edenai import ( EdenAiExplicitImageTool, EdenAiObjectDetectionTool, EdenAiParsingIDTool, EdenAiParsingInvoiceTool, EdenAiSpeechToTextTool, EdenAiTextModerationTool, EdenAiTextToSpeechTool,) ``` * * * #### Help us out by providing feedback on this documentation page:

Eden AI 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 and heading here. LLMs​ See a usage example. from langchain_community.llms import EdenAI Chat models​ See a usage example. from langchain_community.chat_models.edenai import ChatEdenAI Embedding models​ See a usage example. from langchain_community.embeddings.edenai import EdenAiEmbeddings 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. from langchain_community.tools.edenai import ( EdenAiExplicitImageTool, EdenAiObjectDetectionTool, EdenAiParsingIDTool, EdenAiParsingInvoiceTool, EdenAiSpeechToTextTool, EdenAiTextModerationTool, EdenAiTextToSpeechTool, ) Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/facebook/

## 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[​](#embedding-models "Direct link to Embedding models") ### LASER[​](#laser "Direct link to 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) ``` pip install laser_encoders ``` See a [usage example](https://python.langchain.com/docs/integrations/text_embedding/laser/). ``` from langchain_community.embeddings.laser import LaserEmbeddings ``` ## Document loaders[​](#document-loaders "Direct link to Document loaders") ### Facebook Messenger[​](#facebook-messenger "Direct link to 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](https://python.langchain.com/docs/integrations/document_loaders/facebook_chat/). ``` from langchain_community.document_loaders import FacebookChatLoader ``` ## Vector stores[​](#vector-stores "Direct link to Vector stores") ### Facebook Faiss[​](#facebook-faiss "Direct link to 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. ``` pip install faiss-gpu # For CUDA 7.5+ supported GPU's. ``` OR ``` pip install faiss-cpu # For CPU Installation ``` See a [usage example](https://python.langchain.com/docs/integrations/vectorstores/faiss/). ``` from langchain_community.vectorstores import FAISS ``` ## Chat loaders[​](#chat-loaders "Direct link to Chat loaders") ### Facebook Messenger[​](#facebook-messenger-1 "Direct link to 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](https://python.langchain.com/docs/integrations/chat_loaders/facebook/). ``` from langchain_community.chat_loaders.facebook_messenger import ( FolderFacebookMessengerChatLoader, SingleFileFacebookMessengerChatLoader,) ``` ### Facebook WhatsApp[​](#facebook-whatsapp "Direct link to Facebook WhatsApp") See a [usage example](https://python.langchain.com/docs/integrations/chat_loaders/whatsapp/). ``` from langchain_community.chat_loaders.whatsapp import WhatsAppChatLoader ``` * * * #### Help us out by providing feedback on this documentation page:

Facebook - Meta Meta Platforms, Inc., 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 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 pip install laser_encoders See a usage example. from langchain_community.embeddings.laser import LaserEmbeddings Document loaders​ Facebook Messenger​ Messenger 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. from langchain_community.document_loaders import FacebookChatLoader Vector stores​ Facebook Faiss​ Facebook AI Similarity Search (Faiss) 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. We need to install faiss python package. pip install faiss-gpu # For CUDA 7.5+ supported GPU's. OR pip install faiss-cpu # For CPU Installation See a usage example. from langchain_community.vectorstores import FAISS Chat loaders​ Facebook Messenger​ Messenger 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. from langchain_community.chat_loaders.facebook_messenger import ( FolderFacebookMessengerChatLoader, SingleFileFacebookMessengerChatLoader, ) Facebook WhatsApp​ See a usage example. from langchain_community.chat_loaders.whatsapp import WhatsAppChatLoader Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/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. First, you need to install `lxml` and `html2text` python packages. ``` pip install lxmlpip install html2text ```

EverNote 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. First, you need to install lxml and html2text python packages. pip install lxml pip install html2text

https://python.langchain.com/docs/integrations/providers/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. First, you need to set up an ElevenLabs account. You can follow the [instructions here](https://docs.elevenlabs.io/welcome/introduction). ``` from langchain_community.tools import ElevenLabsText2SpeechTool ```

ElevenLabs 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. First, you need to set up an ElevenLabs account. You can follow the instructions here. from langchain_community.tools import ElevenLabsText2SpeechTool

https://python.langchain.com/docs/integrations/providers/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. There exists a wrapper around Epsilla vector databases, allowing you to use it as a vectorstore, whether for semantic search or example selection. ``` from langchain_community.vectorstores import Epsilla ```

This page covers how to use Epsilla within LangChain. It is broken into two parts: installation and setup, and then references to specific Epsilla wrappers. There exists a wrapper around Epsilla vector databases, allowing you to use it as a vectorstore, whether for semantic search or example selection. from langchain_community.vectorstores import Epsilla

https://python.langchain.com/docs/integrations/providers/elasticsearch/

## 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[​](#installation-and-setup "Direct link to Installation and Setup") There are two ways to get started with Elasticsearch: #### Install Elasticsearch on your local machine via docker[​](#install-elasticsearch-on-your-local-machine-via-docker "Direct link to 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. ``` 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[​](#deploy-elasticsearch-on-elastic-cloud "Direct link to 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[​](#install-client "Direct link to Install Client") ``` pip install elasticsearchpip install langchain-elasticsearch ``` ## Embedding models[​](#embedding-models "Direct link to Embedding models") See a [usage example](https://python.langchain.com/docs/integrations/text_embedding/elasticsearch/). ``` from langchain_elasticsearch.embeddings import ElasticsearchEmbeddings ``` ## Vector store[​](#vector-store "Direct link to Vector store") See a [usage example](https://python.langchain.com/docs/integrations/vectorstores/elasticsearch/). ``` from langchain_elasticsearch.vectorstores import ElasticsearchStore ``` ## Memory[​](#memory "Direct link to Memory") See a [usage example](https://python.langchain.com/docs/integrations/memory/elasticsearch_chat_message_history/). ``` from langchain_elasticsearch.chat_history import ElasticsearchChatMessageHistory ``` * * * #### Help us out by providing feedback on this documentation page:

Elasticsearch 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​ 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. 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. Install Client​ pip install elasticsearch pip install langchain-elasticsearch Embedding models​ See a usage example. from langchain_elasticsearch.embeddings import ElasticsearchEmbeddings Vector store​ See a usage example. from langchain_elasticsearch.vectorstores import ElasticsearchStore Memory​ See a usage example. from langchain_elasticsearch.chat_history import ElasticsearchChatMessageHistory Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/imsdb/

## IMSDb > [IMSDb](https://imsdb.com/) is the `Internet Movie Script Database`. > > ## Installation and Setup[​](#installation-and-setup "Direct link to Installation and Setup") There isn't any special setup for it. ## Document Loader[​](#document-loader "Direct link to Document Loader") See a [usage example](https://python.langchain.com/docs/integrations/document_loaders/imsdb/). ``` from langchain_community.document_loaders import IMSDbLoader ``` * * * #### Help us out by providing feedback on this documentation page:

IMSDb IMSDb is the Internet Movie Script Database. Installation and Setup​ There isn't any special setup for it. Document Loader​ See a usage example. from langchain_community.document_loaders import IMSDbLoader Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/etherscan/

## 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[​](#installation-and-setup "Direct link to Installation and Setup") See the detailed [installation guide](https://python.langchain.com/docs/integrations/document_loaders/etherscan/). ## Document Loader[​](#document-loader "Direct link to Document Loader") See a [usage example](https://python.langchain.com/docs/integrations/document_loaders/etherscan/). ``` from langchain_community.document_loaders import EtherscanLoader ``` * * * #### Help us out by providing feedback on this documentation page:

Etherscan Etherscan 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. Document Loader​ See a usage example. from langchain_community.document_loaders import EtherscanLoader Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/fauna/

We have to install the `fauna` package. ``` from langchain_community.document_loaders.fauna import FaunaLoader ```

We have to install the fauna package. from langchain_community.document_loaders.fauna import FaunaLoader

https://python.langchain.com/docs/integrations/providers/fiddler/

## Fiddler > [Fiddler](https://www.fiddler.ai/) provides a unified platform to monitor, explain, analyze, and improve ML deployments at an enterprise scale. ## Installation and Setup[​](#installation-and-setup "Direct link to Installation and Setup") Set up your model [with Fiddler](https://demo.fiddler.ai/): * The URL you're using to connect to Fiddler * Your organization ID * Your authorization token Install the Python package: ``` pip install fiddler-client ``` ## Callbacks[​](#callbacks "Direct link to Callbacks") ``` from langchain_community.callbacks.fiddler_callback import FiddlerCallbackHandler ``` See an [example](https://python.langchain.com/docs/integrations/callbacks/fiddler/). * * * #### Help us out by providing feedback on this documentation page:

Fiddler Fiddler provides a unified platform to monitor, explain, analyze, and improve ML deployments at an enterprise scale. Installation and Setup​ Set up your model with Fiddler: The URL you're using to connect to Fiddler Your organization ID Your authorization token Install the Python package: pip install fiddler-client Callbacks​ from langchain_community.callbacks.fiddler_callback import FiddlerCallbackHandler See an example. Help us out by providing feedback on this documentation page:

https://python.langchain.com/docs/integrations/providers/fireworks/

## Fireworks This page covers how to use [Fireworks](https://fireworks.ai/) models within Langchain. ## Installation and setup[​](#installation-and-setup "Direct link to Installation and setup") * Install the Fireworks integration package. ``` pip install langchain-fireworks ``` * Get a Fireworks API key by signing up at [fireworks.ai](https://fireworks.ai/). * Authenticate by setting the FIREWORKS\_API\_KEY environment variable. ## Authentication[​](#authentication "Direct link to Authentication") There are two ways to authenticate using your Fireworks API key: 1. Setting the `FIREWORKS_API_KEY` environment variable. ``` os.environ["FIREWORKS_API_KEY"] = "<KEY>" ``` 2. Setting `api_key` field in the Fireworks LLM module. ``` llm = Fireworks(api_key="<KEY>") ``` ## Using the Fireworks LLM module[​](#using-the-fireworks-llm-module "Direct link to Using the Fireworks LLM module") Fireworks integrates with Langchain through the LLM module. In this example, we will work the mixtral-8x7b-instruct model. ``` from langchain_fireworks import Fireworks llm = Fireworks( api_key="<KEY>", model="accounts/fireworks/models/mixtral-8x7b-instruct", max_tokens=256)llm("Name 3 sports.") ``` For a more detailed walkthrough, see [here](https://python.langchain.com/docs/integrations/llms/Fireworks/).

Fireworks This page covers how to use Fireworks models within Langchain. Installation and setup​ Install the Fireworks integration package. pip install langchain-fireworks Get a Fireworks API key by signing up at fireworks.ai. Authenticate by setting the FIREWORKS_API_KEY environment variable. Authentication​ There are two ways to authenticate using your Fireworks API key: Setting the FIREWORKS_API_KEY environment variable. os.environ["FIREWORKS_API_KEY"] = "<KEY>" Setting api_key field in the Fireworks LLM module. llm = Fireworks(api_key="<KEY>") Using the Fireworks LLM module​ Fireworks integrates with Langchain through the LLM module. In this example, we will work the mixtral-8x7b-instruct model. from langchain_fireworks import Fireworks llm = Fireworks( api_key="<KEY>", model="accounts/fireworks/models/mixtral-8x7b-instruct", max_tokens=256) llm("Name 3 sports.") For a more detailed walkthrough, see here.

https://python.langchain.com/docs/integrations/providers/jaguar/

This page describes how to use Jaguar vector database within LangChain. It contains three sections: introduction, installation and setup, and Jaguar API. You can run JaguarDB in docker container; or download the software and run on-cloud or off-cloud. ``` export OPENAI_API_KEY="......"export JAGUAR_API_KEY="......" ``` Together with LangChain, a Jaguar client class is provided by importing it in Python:

This page describes how to use Jaguar vector database within LangChain. It contains three sections: introduction, installation and setup, and Jaguar API. You can run JaguarDB in docker container; or download the software and run on-cloud or off-cloud. export OPENAI_API_KEY="......" export JAGUAR_API_KEY="......" Together with LangChain, a Jaguar client class is provided by importing it in Python: