Retrievers
class langchain.retrievers.AmazonKendraRetriever(index_id, region_name=None, credentials_profile_name=None, top_k=3, attribute_filter=None, client=None)[source]
Bases: langchain.schema.BaseRetriever
Retriever class to query documents from Amazon Kendra Index.
Parameters
index_id (str) – Kendra index id
region_name (Optional[str]) – The aws region e.g., us-west-2.
Fallsback to AWS_DEFAULT_REGION env variable
or region specified in ~/.aws/config.
credentials_profile_name (Optional[str]) – The name of the profile in the ~/.aws/credentials
or ~/.aws/config files, which has either access keys or role information
specified. If not specified, the default credential profile or, if on an
EC2 instance, credentials from IMDS will be used.
top_k (int) – No of results to return
attribute_filter (Optional[Dict]) – Additional filtering of results based on metadata
See: https://docs.aws.amazon.com/kendra/latest/APIReference
client (Optional[Any]) – boto3 client for Kendra
Example
retriever = AmazonKendraRetriever(
    index_id="c0806df7-e76b-4bce-9b5c-d5582f6b1a03"
)
get_relevant_documents(query)[source]
Run search on Kendra index and get top k documents
Example:
.. code-block:: python
docs = retriever.get_relevant_documents(‘This is my query’)
Parameters
query (str) –
Return type
List[langchain.schema.Document]
async aget_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns


Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
class langchain.retrievers.ArxivRetriever(*, arxiv_search=None, arxiv_exceptions=None, top_k_results=3, load_max_docs=100, load_all_available_meta=False, doc_content_chars_max=4000, ARXIV_MAX_QUERY_LENGTH=300)[source]
Bases: langchain.schema.BaseRetriever, langchain.utilities.arxiv.ArxivAPIWrapper
It is effectively a wrapper for ArxivAPIWrapper.
It wraps load() to get_relevant_documents().
It uses all ArxivAPIWrapper arguments without any change.
Parameters
arxiv_search (Any) –
arxiv_exceptions (Any) –
top_k_results (int) –
load_max_docs (int) –
load_all_available_meta (bool) –
doc_content_chars_max (Optional[int]) –
ARXIV_MAX_QUERY_LENGTH (int) –
Return type
None
async aget_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
get_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
class langchain.retrievers.AzureCognitiveSearchRetriever(*, service_name='', index_name='', api_key='', api_version='2020-06-30', aiosession=None, content_key='content')[source]


Bases: langchain.schema.BaseRetriever, pydantic.main.BaseModel
Wrapper around Azure Cognitive Search.
Parameters
service_name (str) –
index_name (str) –
api_key (str) –
api_version (str) –
aiosession (Optional[aiohttp.client.ClientSession]) –
content_key (str) –
Return type
None
attribute aiosession: Optional[aiohttp.client.ClientSession] = None
ClientSession, in case we want to reuse connection for better performance.
attribute api_key: str = ''
API Key. Both Admin and Query keys work, but for reading data it’s
recommended to use a Query key.
attribute api_version: str = '2020-06-30'
API version
attribute content_key: str = 'content'
Key in a retrieved result to set as the Document page_content.
attribute index_name: str = ''
Name of Index inside Azure Cognitive Search service
attribute service_name: str = ''
Name of Azure Cognitive Search service
async aget_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
get_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
class langchain.retrievers.ChatGPTPluginRetriever(*, url, bearer_token, top_k=3, filter=None, aiosession=None)[source]
Bases: langchain.schema.BaseRetriever, pydantic.main.BaseModel
Parameters


Bases: langchain.schema.BaseRetriever, pydantic.main.BaseModel
Parameters
url (str) –
bearer_token (str) –
top_k (int) –
filter (Optional[dict]) –
aiosession (Optional[aiohttp.client.ClientSession]) –
Return type
None
attribute aiosession: Optional[aiohttp.client.ClientSession] = None
attribute bearer_token: str [Required]
attribute filter: Optional[dict] = None
attribute top_k: int = 3
attribute url: str [Required]
async aget_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
get_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
class langchain.retrievers.ContextualCompressionRetriever(*, base_compressor, base_retriever)[source]
Bases: langchain.schema.BaseRetriever, pydantic.main.BaseModel
Retriever that wraps a base retriever and compresses the results.
Parameters
base_compressor (langchain.retrievers.document_compressors.base.BaseDocumentCompressor) –
base_retriever (langchain.schema.BaseRetriever) –
Return type
None
attribute base_compressor: langchain.retrievers.document_compressors.base.BaseDocumentCompressor [Required]
Compressor for compressing retrieved documents.
attribute base_retriever: langchain.schema.BaseRetriever [Required]


attribute base_retriever: langchain.schema.BaseRetriever [Required]
Base Retriever to use for getting relevant documents.
async aget_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
get_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
Sequence of relevant documents
Return type
List[langchain.schema.Document]
class langchain.retrievers.DataberryRetriever(datastore_url, top_k=None, api_key=None)[source]
Bases: langchain.schema.BaseRetriever
Retriever that uses the Databerry API.
Parameters
datastore_url (str) –
top_k (Optional[int]) –
api_key (Optional[str]) –
datastore_url: str
api_key: Optional[str]
top_k: Optional[int]
get_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
async aget_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
class langchain.retrievers.ElasticSearchBM25Retriever(client, index_name)[source]
Bases: langchain.schema.BaseRetriever
Wrapper around Elasticsearch using BM25 as a retrieval method.


Wrapper around Elasticsearch using BM25 as a retrieval method.
To connect to an Elasticsearch instance that requires login credentials,
including Elastic Cloud, use the Elasticsearch URL format
https://username:password@es_host:9243. For example, to connect to Elastic
Cloud, create the Elasticsearch URL with the required authentication details and
pass it to the ElasticVectorSearch constructor as the named parameter
elasticsearch_url.
You can obtain your Elastic Cloud URL and login credentials by logging in to the
Elastic Cloud console at https://cloud.elastic.co, selecting your deployment, and
navigating to the “Deployments” page.
To obtain your Elastic Cloud password for the default “elastic” user:
Log in to the Elastic Cloud console at https://cloud.elastic.co
Go to “Security” > “Users”
Locate the “elastic” user and click “Edit”
Click “Reset password”
Follow the prompts to reset the password
The format for Elastic Cloud URLs is
https://username:password@cluster_id.region_id.gcp.cloud.es.io:9243.
Parameters
client (Any) –
index_name (str) –
classmethod create(elasticsearch_url, index_name, k1=2.0, b=0.75)[source]
Parameters
elasticsearch_url (str) –
index_name (str) –
k1 (float) –
b (float) –
Return type
langchain.retrievers.elastic_search_bm25.ElasticSearchBM25Retriever
add_texts(texts, refresh_indices=True)[source]
Run more texts through the embeddings and add to the retriever.
Parameters
texts (Iterable[str]) – Iterable of strings to add to the retriever.
refresh_indices (bool) – bool to refresh ElasticSearch indices
Returns


refresh_indices (bool) – bool to refresh ElasticSearch indices
Returns
List of ids from adding the texts into the retriever.
Return type
List[str]
get_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
async aget_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
class langchain.retrievers.KNNRetriever(*, embeddings, index=None, texts, k=4, relevancy_threshold=None)[source]
Bases: langchain.schema.BaseRetriever, pydantic.main.BaseModel
KNN Retriever.
Parameters
embeddings (langchain.embeddings.base.Embeddings) –
index (Any) –
texts (List[str]) –
k (int) –
relevancy_threshold (Optional[float]) –
Return type
None
attribute embeddings: langchain.embeddings.base.Embeddings [Required]
attribute index: Any = None
attribute k: int = 4
attribute relevancy_threshold: Optional[float] = None
attribute texts: List[str] [Required]
async aget_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
classmethod from_texts(texts, embeddings, **kwargs)[source]
Parameters
texts (List[str]) –


Parameters
texts (List[str]) –
embeddings (langchain.embeddings.base.Embeddings) –
kwargs (Any) –
Return type
langchain.retrievers.knn.KNNRetriever
get_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
class langchain.retrievers.LlamaIndexGraphRetriever(*, graph=None, query_configs=None)[source]
Bases: langchain.schema.BaseRetriever, pydantic.main.BaseModel
Question-answering with sources over an LlamaIndex graph data structure.
Parameters
graph (Any) –
query_configs (List[Dict]) –
Return type
None
attribute graph: Any = None
attribute query_configs: List[Dict] [Optional]
async aget_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
get_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) –
Return type
List[langchain.schema.Document]
class langchain.retrievers.LlamaIndexRetriever(*, index=None, query_kwargs=None)[source]
Bases: langchain.schema.BaseRetriever, pydantic.main.BaseModel
Question-answering with sources over an LlamaIndex data structure.
Parameters
index (Any) –
query_kwargs (Dict) –
Return type
None
attribute index: Any = None


Return type
None
attribute index: Any = None
attribute query_kwargs: Dict [Optional]
async aget_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
get_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) –
Return type
List[langchain.schema.Document]
class langchain.retrievers.MergerRetriever(retrievers)[source]
Bases: langchain.schema.BaseRetriever
This class merges the results of multiple retrievers.
Parameters
retrievers (List[langchain.schema.BaseRetriever]) – A list of retrievers to merge.
get_relevant_documents(query)[source]
Get the relevant documents for a given query.
Parameters
query (str) – The query to search for.
Returns
A list of relevant documents.
Return type
List[langchain.schema.Document]
async aget_relevant_documents(query)[source]
Asynchronously get the relevant documents for a given query.
Parameters
query (str) – The query to search for.
Returns
A list of relevant documents.
Return type
List[langchain.schema.Document]
merge_documents(query)[source]
Merge the results of the retrievers.
Parameters
query (str) – The query to search for.
Returns
A list of merged documents.
Return type
List[langchain.schema.Document]
async amerge_documents(query)[source]
Asynchronously merge the results of the retrievers.
Parameters
query (str) – The query to search for.
Returns
A list of merged documents.
Return type


Returns
A list of merged documents.
Return type
List[langchain.schema.Document]
class langchain.retrievers.MetalRetriever(client, params=None)[source]
Bases: langchain.schema.BaseRetriever
Retriever that uses the Metal API.
Parameters
client (Any) –
params (Optional[dict]) –
get_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
async aget_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
class langchain.retrievers.MilvusRetriever(embedding_function, collection_name='LangChainCollection', connection_args=None, consistency_level='Session', search_params=None)[source]
Bases: langchain.schema.BaseRetriever
Retriever that uses the Milvus API.
Parameters
embedding_function (langchain.embeddings.base.Embeddings) –
collection_name (str) –
connection_args (Optional[Dict[str, Any]]) –
consistency_level (str) –
search_params (Optional[dict]) –
add_texts(texts, metadatas=None)[source]
Add text to the Milvus store
Parameters
texts (List[str]) – The text
metadatas (List[dict]) – Metadata dicts, must line up with existing store
Return type
None
get_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns


Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
async aget_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
class langchain.retrievers.PineconeHybridSearchRetriever(*, embeddings, sparse_encoder=None, index=None, top_k=4, alpha=0.5)[source]
Bases: langchain.schema.BaseRetriever, pydantic.main.BaseModel
Parameters
embeddings (langchain.embeddings.base.Embeddings) –
sparse_encoder (Any) –
index (Any) –
top_k (int) –
alpha (float) –
Return type
None
attribute alpha: float = 0.5
attribute embeddings: langchain.embeddings.base.Embeddings [Required]
attribute index: Any = None
attribute sparse_encoder: Any = None
attribute top_k: int = 4
add_texts(texts, ids=None, metadatas=None)[source]
Parameters
texts (List[str]) –
ids (Optional[List[str]]) –
metadatas (Optional[List[dict]]) –
Return type
None
async aget_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
get_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns


Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
class langchain.retrievers.PubMedRetriever(*, top_k_results=3, load_max_docs=25, doc_content_chars_max=2000, load_all_available_meta=False, email='your_email@example.com', base_url_esearch='https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi?', base_url_efetch='https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?', max_retry=5, sleep_time=0.2, ARXIV_MAX_QUERY_LENGTH=300)[source]
Bases: langchain.schema.BaseRetriever, langchain.utilities.pupmed.PubMedAPIWrapper
It is effectively a wrapper for PubMedAPIWrapper.
It wraps load() to get_relevant_documents().
It uses all PubMedAPIWrapper arguments without any change.
Parameters
top_k_results (int) –
load_max_docs (int) –
doc_content_chars_max (int) –
load_all_available_meta (bool) –
email (str) –
base_url_esearch (str) –
base_url_efetch (str) –
max_retry (int) –
sleep_time (float) –
ARXIV_MAX_QUERY_LENGTH (int) –
Return type
None
async aget_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
get_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns


Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
class langchain.retrievers.RemoteLangChainRetriever(*, url, headers=None, input_key='message', response_key='response', page_content_key='page_content', metadata_key='metadata')[source]
Bases: langchain.schema.BaseRetriever, pydantic.main.BaseModel
Parameters
url (str) –
headers (Optional[dict]) –
input_key (str) –
response_key (str) –
page_content_key (str) –
metadata_key (str) –
Return type
None
attribute headers: Optional[dict] = None
attribute input_key: str = 'message'
attribute metadata_key: str = 'metadata'
attribute page_content_key: str = 'page_content'
attribute response_key: str = 'response'
attribute url: str [Required]
async aget_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
get_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
class langchain.retrievers.SVMRetriever(*, embeddings, index=None, texts, k=4, relevancy_threshold=None)[source]
Bases: langchain.schema.BaseRetriever, pydantic.main.BaseModel
SVM Retriever.
Parameters


SVM Retriever.
Parameters
embeddings (langchain.embeddings.base.Embeddings) –
index (Any) –
texts (List[str]) –
k (int) –
relevancy_threshold (Optional[float]) –
Return type
None
attribute embeddings: langchain.embeddings.base.Embeddings [Required]
attribute index: Any = None
attribute k: int = 4
attribute relevancy_threshold: Optional[float] = None
attribute texts: List[str] [Required]
async aget_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
classmethod from_texts(texts, embeddings, **kwargs)[source]
Parameters
texts (List[str]) –
embeddings (langchain.embeddings.base.Embeddings) –
kwargs (Any) –
Return type
langchain.retrievers.svm.SVMRetriever
get_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
class langchain.retrievers.SelfQueryRetriever(*, vectorstore, llm_chain, search_type='similarity', search_kwargs=None, structured_query_translator, verbose=False, use_original_query=False)[source]
Bases: langchain.schema.BaseRetriever, pydantic.main.BaseModel
Retriever that wraps around a vector store and uses an LLM to generate
the vector store queries.
Parameters
vectorstore (langchain.vectorstores.base.VectorStore) –


Parameters
vectorstore (langchain.vectorstores.base.VectorStore) –
llm_chain (langchain.chains.llm.LLMChain) –
search_type (str) –
search_kwargs (dict) –
structured_query_translator (langchain.chains.query_constructor.ir.Visitor) –
verbose (bool) –
use_original_query (bool) –
Return type
None
attribute llm_chain: langchain.chains.llm.LLMChain [Required]
The LLMChain for generating the vector store queries.
attribute search_kwargs: dict [Optional]
Keyword arguments to pass in to the vector store search.
attribute search_type: str = 'similarity'
The search type to perform on the vector store.
attribute structured_query_translator: langchain.chains.query_constructor.ir.Visitor [Required]
Translator for turning internal query language into vectorstore search params.
attribute use_original_query: bool = False
attribute vectorstore: langchain.vectorstores.base.VectorStore [Required]
The underlying vector store from which documents will be retrieved.
attribute verbose: bool = False
Use original query instead of the revised new query from LLM
async aget_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
classmethod from_llm(llm, vectorstore, document_contents, metadata_field_info, structured_query_translator=None, chain_kwargs=None, enable_limit=False, use_original_query=False, **kwargs)[source]
Parameters
llm (langchain.base_language.BaseLanguageModel) –
vectorstore (langchain.vectorstores.base.VectorStore) –
document_contents (str) –


document_contents (str) –
metadata_field_info (List[langchain.chains.query_constructor.schema.AttributeInfo]) –
structured_query_translator (Optional[langchain.chains.query_constructor.ir.Visitor]) –
chain_kwargs (Optional[Dict]) –
enable_limit (bool) –
use_original_query (bool) –
kwargs (Any) –
Return type
langchain.retrievers.self_query.base.SelfQueryRetriever
get_relevant_documents(query, callbacks=None)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
callbacks (Optional[Union[List[langchain.callbacks.base.BaseCallbackHandler], langchain.callbacks.base.BaseCallbackManager]]) –
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
class langchain.retrievers.TFIDFRetriever(*, vectorizer=None, docs, tfidf_array=None, k=4)[source]
Bases: langchain.schema.BaseRetriever, pydantic.main.BaseModel
Parameters
vectorizer (Any) –
docs (List[langchain.schema.Document]) –
tfidf_array (Any) –
k (int) –
Return type
None
attribute docs: List[langchain.schema.Document] [Required]
attribute k: int = 4
attribute tfidf_array: Any = None
attribute vectorizer: Any = None
async aget_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
classmethod from_documents(documents, *, tfidf_params=None, **kwargs)[source]
Parameters


Parameters
documents (Iterable[langchain.schema.Document]) –
tfidf_params (Optional[Dict[str, Any]]) –
kwargs (Any) –
Return type
langchain.retrievers.tfidf.TFIDFRetriever
classmethod from_texts(texts, metadatas=None, tfidf_params=None, **kwargs)[source]
Parameters
texts (Iterable[str]) –
metadatas (Optional[Iterable[dict]]) –
tfidf_params (Optional[Dict[str, Any]]) –
kwargs (Any) –
Return type
langchain.retrievers.tfidf.TFIDFRetriever
get_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
class langchain.retrievers.TimeWeightedVectorStoreRetriever(*, vectorstore, search_kwargs=None, memory_stream=None, decay_rate=0.01, k=4, other_score_keys=[], default_salience=None)[source]
Bases: langchain.schema.BaseRetriever, pydantic.main.BaseModel
Retriever combining embedding similarity with recency.
Parameters
vectorstore (langchain.vectorstores.base.VectorStore) –
search_kwargs (dict) –
memory_stream (List[langchain.schema.Document]) –
decay_rate (float) –
k (int) –
other_score_keys (List[str]) –
default_salience (Optional[float]) –
Return type
None
attribute decay_rate: float = 0.01
The exponential decay factor used as (1.0-decay_rate)**(hrs_passed).
attribute default_salience: Optional[float] = None


attribute default_salience: Optional[float] = None
The salience to assign memories not retrieved from the vector store.
None assigns no salience to documents not fetched from the vector store.
attribute k: int = 4
The maximum number of documents to retrieve in a given call.
attribute memory_stream: List[langchain.schema.Document] [Optional]
The memory_stream of documents to search through.
attribute other_score_keys: List[str] = []
Other keys in the metadata to factor into the score, e.g. ‘importance’.
attribute search_kwargs: dict [Optional]
Keyword arguments to pass to the vectorstore similarity search.
attribute vectorstore: langchain.vectorstores.base.VectorStore [Required]
The vectorstore to store documents and determine salience.
async aadd_documents(documents, **kwargs)[source]
Add documents to vectorstore.
Parameters
documents (List[langchain.schema.Document]) –
kwargs (Any) –
Return type
List[str]
add_documents(documents, **kwargs)[source]
Add documents to vectorstore.
Parameters
documents (List[langchain.schema.Document]) –
kwargs (Any) –
Return type
List[str]
async aget_relevant_documents(query)[source]
Return documents that are relevant to the query.
Parameters
query (str) –
Return type
List[langchain.schema.Document]
get_relevant_documents(query)[source]
Return documents that are relevant to the query.
Parameters
query (str) –
Return type
List[langchain.schema.Document]
get_salient_docs(query)[source]
Return documents that are salient to the query.
Parameters
query (str) –
Return type


Parameters
query (str) –
Return type
Dict[int, Tuple[langchain.schema.Document, float]]
class langchain.retrievers.VespaRetriever(app, body, content_field, metadata_fields=None)[source]
Bases: langchain.schema.BaseRetriever
Retriever that uses the Vespa.
Parameters
app (Vespa) –
body (Dict) –
content_field (str) –
metadata_fields (Optional[Sequence[str]]) –
get_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
async aget_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
get_relevant_documents_with_filter(query, *, _filter=None)[source]
Parameters
query (str) –
_filter (Optional[str]) –
Return type
List[langchain.schema.Document]
classmethod from_params(url, content_field, *, k=None, metadata_fields=(), sources=None, _filter=None, yql=None, **kwargs)[source]
Instantiate retriever from params.
Parameters
url (str) – Vespa app URL.
content_field (str) – Field in results to return as Document page_content.
k (Optional[int]) – Number of Documents to return. Defaults to None.
metadata_fields (Sequence[str] or "*") – Fields in results to include in
document metadata. Defaults to empty tuple ().
sources (Sequence[str] or "*" or None) – Sources to retrieve
from. Defaults to None.


from. Defaults to None.
_filter (Optional[str]) – Document filter condition expressed in YQL.
Defaults to None.
yql (Optional[str]) – Full YQL query to be used. Should not be specified
if _filter or sources are specified. Defaults to None.
kwargs (Any) – Keyword arguments added to query body.
Return type
langchain.retrievers.vespa_retriever.VespaRetriever
class langchain.retrievers.WeaviateHybridSearchRetriever(client, index_name, text_key, alpha=0.5, k=4, attributes=None, create_schema_if_missing=True)[source]
Bases: langchain.schema.BaseRetriever
Parameters
client (Any) –
index_name (str) –
text_key (str) –
alpha (float) –
k (int) –
attributes (Optional[List[str]]) –
create_schema_if_missing (bool) –
class Config[source]
Bases: object
Configuration for this pydantic object.
extra = 'forbid'
arbitrary_types_allowed = True
add_documents(docs, **kwargs)[source]
Upload documents to Weaviate.
Parameters
docs (List[langchain.schema.Document]) –
kwargs (Any) –
Return type
List[str]
get_relevant_documents(query, where_filter=None)[source]
Look up similar documents in Weaviate.
Parameters
query (str) –
where_filter (Optional[Dict[str, object]]) –
Return type
List[langchain.schema.Document]
async aget_relevant_documents(query, where_filter=None)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for


Parameters
query (str) – string to find relevant documents for
where_filter (Optional[Dict[str, object]]) –
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
class langchain.retrievers.WikipediaRetriever(*, wiki_client=None, top_k_results=3, lang='en', load_all_available_meta=False, doc_content_chars_max=4000)[source]
Bases: langchain.schema.BaseRetriever, langchain.utilities.wikipedia.WikipediaAPIWrapper
It is effectively a wrapper for WikipediaAPIWrapper.
It wraps load() to get_relevant_documents().
It uses all WikipediaAPIWrapper arguments without any change.
Parameters
wiki_client (Any) –
top_k_results (int) –
lang (str) –
load_all_available_meta (bool) –
doc_content_chars_max (int) –
Return type
None
async aget_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
get_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
class langchain.retrievers.ZepRetriever(session_id, url, top_k=None)[source]
Bases: langchain.schema.BaseRetriever
A Retriever implementation for the Zep long-term memory store. Search your
user’s long-term chat history with Zep.
Note: You will need to provide the user’s session_id to use this retriever.
More on Zep:


More on Zep:
Zep provides long-term conversation storage for LLM apps. The server stores,
summarizes, embeds, indexes, and enriches conversational AI chat
histories, and exposes them via simple, low-latency APIs.
For server installation instructions, see:
https://getzep.github.io/deployment/quickstart/
Parameters
session_id (str) –
url (str) –
top_k (Optional[int]) –
get_relevant_documents(query, metadata=None)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
metadata (Optional[Dict]) –
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
async aget_relevant_documents(query, metadata=None)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
metadata (Optional[Dict]) –
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
class langchain.retrievers.ZillizRetriever(embedding_function, collection_name='LangChainCollection', connection_args=None, consistency_level='Session', search_params=None)[source]
Bases: langchain.schema.BaseRetriever
Retriever that uses the Zilliz API.
Parameters
embedding_function (langchain.embeddings.base.Embeddings) –
collection_name (str) –
connection_args (Optional[Dict[str, Any]]) –
consistency_level (str) –
search_params (Optional[dict]) –
add_texts(texts, metadatas=None)[source]
Add text to the Zilliz store
Parameters
texts (List[str]) – The text


Add text to the Zilliz store
Parameters
texts (List[str]) – The text
metadatas (List[dict]) – Metadata dicts, must line up with existing store
Return type
None
get_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
async aget_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
class langchain.retrievers.DocArrayRetriever(*, index=None, embeddings, search_field, content_field, search_type=SearchType.similarity, top_k=1, filters=None)[source]
Bases: langchain.schema.BaseRetriever, pydantic.main.BaseModel
Retriever class for DocArray Document Indices.
Currently, supports 5 backends:
InMemoryExactNNIndex, HnswDocumentIndex, QdrantDocumentIndex,
ElasticDocIndex, and WeaviateDocumentIndex.
Parameters
index (Any) –
embeddings (langchain.embeddings.base.Embeddings) –
search_field (str) –
content_field (str) –
search_type (langchain.retrievers.docarray.SearchType) –
top_k (int) –
filters (Optional[Any]) –
Return type
None
index
One of the above-mentioned index instances
embeddings
Embedding model to represent text as vectors
search_field
Field to consider for searching in the documents.
Should be an embedding/vector/tensor.
content_field


Should be an embedding/vector/tensor.
content_field
Field that represents the main content in your document schema.
Will be used as a page_content. Everything else will go into metadata.
search_type
Type of search to perform (similarity / mmr)
filters
Filters applied for document retrieval.
top_k
Number of documents to return
attribute content_field: str [Required]
attribute embeddings: langchain.embeddings.base.Embeddings [Required]
attribute filters: Optional[Any] = None
attribute index: Any = None
attribute search_field: str [Required]
attribute search_type: langchain.retrievers.docarray.SearchType = SearchType.similarity
attribute top_k: int = 1
async aget_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
get_relevant_documents(query)[source]
Get documents relevant for a query.
Parameters
query (str) – string to find relevant documents for
Returns
List of relevant documents
Return type
List[langchain.schema.Document]
Document compressors
class langchain.retrievers.document_compressors.DocumentCompressorPipeline(*, transformers)[source]
Bases: langchain.retrievers.document_compressors.base.BaseDocumentCompressor
Document compressor that uses a pipeline of transformers.
Parameters
transformers (List[Union[langchain.schema.BaseDocumentTransformer, langchain.retrievers.document_compressors.base.BaseDocumentCompressor]]) –
Return type
None


Return type
None
attribute transformers: List[Union[langchain.schema.BaseDocumentTransformer, langchain.retrievers.document_compressors.base.BaseDocumentCompressor]] [Required]
List of document filters that are chained together and run in sequence.
async acompress_documents(documents, query)[source]
Compress retrieved documents given the query context.
Parameters
documents (Sequence[langchain.schema.Document]) –
query (str) –
Return type
Sequence[langchain.schema.Document]
compress_documents(documents, query)[source]
Transform a list of documents.
Parameters
documents (Sequence[langchain.schema.Document]) –
query (str) –
Return type
Sequence[langchain.schema.Document]
class langchain.retrievers.document_compressors.EmbeddingsFilter(*, embeddings, similarity_fn=<function cosine_similarity>, k=20, similarity_threshold=None)[source]
Bases: langchain.retrievers.document_compressors.base.BaseDocumentCompressor
Parameters
embeddings (langchain.embeddings.base.Embeddings) –
similarity_fn (Callable) –
k (Optional[int]) –
similarity_threshold (Optional[float]) –
Return type
None
attribute embeddings: langchain.embeddings.base.Embeddings [Required]
Embeddings to use for embedding document contents and queries.
attribute k: Optional[int] = 20
The number of relevant documents to return. Can be set to None, in which case
similarity_threshold must be specified. Defaults to 20.
attribute similarity_fn: Callable = <function cosine_similarity>
Similarity function for comparing documents. Function expected to take as input
two matrices (List[List[float]]) and return a matrix of scores where higher values
indicate greater similarity.
attribute similarity_threshold: Optional[float] = None


indicate greater similarity.
attribute similarity_threshold: Optional[float] = None
Threshold for determining when two documents are similar enough
to be considered redundant. Defaults to None, must be specified if k is set
to None.
async acompress_documents(documents, query)[source]
Filter down documents.
Parameters
documents (Sequence[langchain.schema.Document]) –
query (str) –
Return type
Sequence[langchain.schema.Document]
compress_documents(documents, query)[source]
Filter documents based on similarity of their embeddings to the query.
Parameters
documents (Sequence[langchain.schema.Document]) –
query (str) –
Return type
Sequence[langchain.schema.Document]
class langchain.retrievers.document_compressors.LLMChainExtractor(*, llm_chain, get_input=<function default_get_input>)[source]
Bases: langchain.retrievers.document_compressors.base.BaseDocumentCompressor
Parameters
llm_chain (langchain.chains.llm.LLMChain) –
get_input (Callable[[str, langchain.schema.Document], dict]) –
Return type
None
attribute get_input: Callable[[str, langchain.schema.Document], dict] = <function default_get_input>
Callable for constructing the chain input from the query and a Document.
attribute llm_chain: langchain.chains.llm.LLMChain [Required]
LLM wrapper to use for compressing documents.
async acompress_documents(documents, query)[source]
Compress page content of raw documents asynchronously.
Parameters
documents (Sequence[langchain.schema.Document]) –
query (str) –
Return type
Sequence[langchain.schema.Document]
compress_documents(documents, query)[source]
Compress page content of raw documents.
Parameters


Compress page content of raw documents.
Parameters
documents (Sequence[langchain.schema.Document]) –
query (str) –
Return type
Sequence[langchain.schema.Document]
classmethod from_llm(llm, prompt=None, get_input=None, llm_chain_kwargs=None)[source]
Initialize from LLM.
Parameters
llm (langchain.base_language.BaseLanguageModel) –
prompt (Optional[langchain.prompts.prompt.PromptTemplate]) –
get_input (Optional[Callable[[str, langchain.schema.Document], str]]) –
llm_chain_kwargs (Optional[dict]) –
Return type
langchain.retrievers.document_compressors.chain_extract.LLMChainExtractor
class langchain.retrievers.document_compressors.LLMChainFilter(*, llm_chain, get_input=<function default_get_input>)[source]
Bases: langchain.retrievers.document_compressors.base.BaseDocumentCompressor
Filter that drops documents that aren’t relevant to the query.
Parameters
llm_chain (langchain.chains.llm.LLMChain) –
get_input (Callable[[str, langchain.schema.Document], dict]) –
Return type
None
attribute get_input: Callable[[str, langchain.schema.Document], dict] = <function default_get_input>
Callable for constructing the chain input from the query and a Document.
attribute llm_chain: langchain.chains.llm.LLMChain [Required]
LLM wrapper to use for filtering documents.
The chain prompt is expected to have a BooleanOutputParser.
async acompress_documents(documents, query)[source]
Filter down documents.
Parameters
documents (Sequence[langchain.schema.Document]) –
query (str) –
Return type
Sequence[langchain.schema.Document]


query (str) –
Return type
Sequence[langchain.schema.Document]
compress_documents(documents, query)[source]
Filter down documents based on their relevance to the query.
Parameters
documents (Sequence[langchain.schema.Document]) –
query (str) –
Return type
Sequence[langchain.schema.Document]
classmethod from_llm(llm, prompt=None, **kwargs)[source]
Parameters
llm (langchain.base_language.BaseLanguageModel) –
prompt (Optional[langchain.prompts.base.BasePromptTemplate]) –
kwargs (Any) –
Return type
langchain.retrievers.document_compressors.chain_filter.LLMChainFilter
class langchain.retrievers.document_compressors.CohereRerank(*, client, top_n=3, model='rerank-english-v2.0')[source]
Bases: langchain.retrievers.document_compressors.base.BaseDocumentCompressor
Parameters
client (Client) –
top_n (int) –
model (str) –
Return type
None
attribute client: Client [Required]
attribute model: str = 'rerank-english-v2.0'
attribute top_n: int = 3
async acompress_documents(documents, query)[source]
Compress retrieved documents given the query context.
Parameters
documents (Sequence[langchain.schema.Document]) –
query (str) –
Return type
Sequence[langchain.schema.Document]
compress_documents(documents, query)[source]
Compress retrieved documents given the query context.
Parameters
documents (Sequence[langchain.schema.Document]) –
query (str) –
Return type
Sequence[langchain.schema.Document]


Chat Models
class langchain.chat_models.ChatOpenAI(*, cache=None, verbose=None, callbacks=None, callback_manager=None, tags=None, client=None, model='gpt-3.5-turbo', temperature=0.7, model_kwargs=None, openai_api_key=None, openai_api_base=None, openai_organization=None, openai_proxy=None, request_timeout=None, max_retries=6, streaming=False, n=1, max_tokens=None, tiktoken_model_name=None)[source]
Bases: langchain.chat_models.base.BaseChatModel
Wrapper around OpenAI Chat large language models.
To use, you should have the openai python package installed, and the
environment variable OPENAI_API_KEY set with your API key.
Any parameters that are valid to be passed to the openai.create call can be passed
in, even if not explicitly saved on this class.
Example
from langchain.chat_models import ChatOpenAI
openai = ChatOpenAI(model_name="gpt-3.5-turbo")
Parameters
cache (Optional[bool]) –
verbose (bool) –
callbacks (Optional[Union[List[langchain.callbacks.base.BaseCallbackHandler], langchain.callbacks.base.BaseCallbackManager]]) –
callback_manager (Optional[langchain.callbacks.base.BaseCallbackManager]) –
tags (Optional[List[str]]) –
client (Any) –
model (str) –
temperature (float) –
model_kwargs (Dict[str, Any]) –
openai_api_key (Optional[str]) –
openai_api_base (Optional[str]) –
openai_organization (Optional[str]) –
openai_proxy (Optional[str]) –
request_timeout (Optional[Union[float, Tuple[float, float]]]) –
max_retries (int) –
streaming (bool) –


max_retries (int) –
streaming (bool) –
n (int) –
max_tokens (Optional[int]) –
tiktoken_model_name (Optional[str]) –
Return type
None
attribute max_retries: int = 6
Maximum number of retries to make when generating.
attribute max_tokens: Optional[int] = None
Maximum number of tokens to generate.
attribute model_kwargs: Dict[str, Any] [Optional]
Holds any model parameters valid for create call not explicitly specified.
attribute model_name: str = 'gpt-3.5-turbo' (alias 'model')
Model name to use.
attribute n: int = 1
Number of chat completions to generate for each prompt.
attribute openai_api_base: Optional[str] = None
attribute openai_api_key: Optional[str] = None
Base URL path for API requests,
leave blank if not using a proxy or service emulator.
attribute openai_organization: Optional[str] = None
attribute openai_proxy: Optional[str] = None
attribute request_timeout: Optional[Union[float, Tuple[float, float]]] = None
Timeout for requests to OpenAI completion API. Default is 600 seconds.
attribute streaming: bool = False
Whether to stream the results or not.
attribute temperature: float = 0.7
What sampling temperature to use.
attribute tiktoken_model_name: Optional[str] = None
The model name to pass to tiktoken when using this class.
Tiktoken is used to count the number of tokens in documents to constrain
them to be under a certain limit. By default, when set to None, this will
be the same as the embedding model name. However, there are some cases


be the same as the embedding model name. However, there are some cases
where you may want to use this Embedding class with a model name not
supported by tiktoken. This can include when using Azure embeddings or
when using one of the many model providers that expose an OpenAI-like
API but with different models. In those cases, in order to avoid erroring
when tiktoken is called, you can specify a model name to use here.
completion_with_retry(**kwargs)[source]
Use tenacity to retry the completion call.
Parameters
kwargs (Any) –
Return type
Any
get_num_tokens_from_messages(messages)[source]
Calculate num tokens for gpt-3.5-turbo and gpt-4 with tiktoken package.
Official documentation: https://github.com/openai/openai-cookbook/blob/
main/examples/How_to_format_inputs_to_ChatGPT_models.ipynb
Parameters
messages (List[langchain.schema.BaseMessage]) –
Return type
int
get_token_ids(text)[source]
Get the tokens present in the text with tiktoken package.
Parameters
text (str) –
Return type
List[int]
property lc_secrets: Dict[str, str]
Return a map of constructor argument names to secret ids.
eg. {“openai_api_key”: “OPENAI_API_KEY”}
property lc_serializable: bool
Return whether or not the class is serializable.


property lc_serializable: bool
Return whether or not the class is serializable.
class langchain.chat_models.AzureChatOpenAI(*, cache=None, verbose=None, callbacks=None, callback_manager=None, tags=None, client=None, model='gpt-3.5-turbo', temperature=0.7, model_kwargs=None, openai_api_key='', openai_api_base='', openai_organization='', openai_proxy='', request_timeout=None, max_retries=6, streaming=False, n=1, max_tokens=None, tiktoken_model_name=None, deployment_name='', openai_api_type='azure', openai_api_version='')[source]
Bases: langchain.chat_models.openai.ChatOpenAI
Wrapper around Azure OpenAI Chat Completion API. To use this class you
must have a deployed model on Azure OpenAI. Use deployment_name in the
constructor to refer to the “Model deployment name” in the Azure portal.
In addition, you should have the openai python package installed, and the
following environment variables set or passed in constructor in lower case:
- OPENAI_API_TYPE (default: azure)
- OPENAI_API_KEY
- OPENAI_API_BASE
- OPENAI_API_VERSION
- OPENAI_PROXY
For exmaple, if you have gpt-35-turbo deployed, with the deployment name
35-turbo-dev, the constructor should look like:
AzureChatOpenAI(
    deployment_name="35-turbo-dev",
    openai_api_version="2023-03-15-preview",
)
Be aware the API version may change.
Any parameters that are valid to be passed to the openai.create call can be passed
in, even if not explicitly saved on this class.
Parameters
cache (Optional[bool]) –
verbose (bool) –


Parameters
cache (Optional[bool]) –
verbose (bool) –
callbacks (Optional[Union[List[langchain.callbacks.base.BaseCallbackHandler], langchain.callbacks.base.BaseCallbackManager]]) –
callback_manager (Optional[langchain.callbacks.base.BaseCallbackManager]) –
tags (Optional[List[str]]) –
client (Any) –
model (str) –
temperature (float) –
model_kwargs (Dict[str, Any]) –
openai_api_key (str) –
openai_api_base (str) –
openai_organization (str) –
openai_proxy (str) –
request_timeout (Optional[Union[float, Tuple[float, float]]]) –
max_retries (int) –
streaming (bool) –
n (int) –
max_tokens (Optional[int]) –
tiktoken_model_name (Optional[str]) –
deployment_name (str) –
openai_api_type (str) –
openai_api_version (str) –
Return type
None
attribute deployment_name: str = ''
attribute openai_api_base: str = ''
attribute openai_api_key: str = ''
Base URL path for API requests,
leave blank if not using a proxy or service emulator.
attribute openai_api_type: str = 'azure'
attribute openai_api_version: str = ''
attribute openai_organization: str = ''
attribute openai_proxy: str = ''
class langchain.chat_models.FakeListChatModel(*, cache=None, verbose=None, callbacks=None, callback_manager=None, tags=None, responses, i=0)[source]
Bases: langchain.chat_models.base.SimpleChatModel
Fake ChatModel for testing purposes.
Parameters


Fake ChatModel for testing purposes.
Parameters
cache (Optional[bool]) –
verbose (bool) –
callbacks (Optional[Union[List[langchain.callbacks.base.BaseCallbackHandler], langchain.callbacks.base.BaseCallbackManager]]) –
callback_manager (Optional[langchain.callbacks.base.BaseCallbackManager]) –
tags (Optional[List[str]]) –
responses (List) –
i (int) –
Return type
None
attribute i: int = 0
attribute responses: List [Required]
class langchain.chat_models.PromptLayerChatOpenAI(*, cache=None, verbose=None, callbacks=None, callback_manager=None, tags=None, client=None, model='gpt-3.5-turbo', temperature=0.7, model_kwargs=None, openai_api_key=None, openai_api_base=None, openai_organization=None, openai_proxy=None, request_timeout=None, max_retries=6, streaming=False, n=1, max_tokens=None, tiktoken_model_name=None, pl_tags=None, return_pl_id=False)[source]
Bases: langchain.chat_models.openai.ChatOpenAI
Wrapper around OpenAI Chat large language models and PromptLayer.
To use, you should have the openai and promptlayer python
package installed, and the environment variable OPENAI_API_KEY
and PROMPTLAYER_API_KEY set with your openAI API key and
promptlayer key respectively.
All parameters that can be passed to the OpenAI LLM can also
be passed here. The PromptLayerChatOpenAI adds to optional
Parameters
pl_tags (Optional[List[str]]) – List of strings to tag the request with.
return_pl_id (Optional[bool]) – If True, the PromptLayer request ID will be
returned in the generation_info field of the
Generation object.
cache (Optional[bool]) –


Generation object.
cache (Optional[bool]) –
verbose (bool) –
callbacks (Optional[Union[List[langchain.callbacks.base.BaseCallbackHandler], langchain.callbacks.base.BaseCallbackManager]]) –
callback_manager (Optional[langchain.callbacks.base.BaseCallbackManager]) –
tags (Optional[List[str]]) –
client (Any) –
model (str) –
temperature (float) –
model_kwargs (Dict[str, Any]) –
openai_api_key (Optional[str]) –
openai_api_base (Optional[str]) –
openai_organization (Optional[str]) –
openai_proxy (Optional[str]) –
request_timeout (Optional[Union[float, Tuple[float, float]]]) –
max_retries (int) –
streaming (bool) –
n (int) –
max_tokens (Optional[int]) –
tiktoken_model_name (Optional[str]) –
Return type
None
Example
from langchain.chat_models import PromptLayerChatOpenAI
openai = PromptLayerChatOpenAI(model_name="gpt-3.5-turbo")
attribute pl_tags: Optional[List[str]] = None
attribute return_pl_id: Optional[bool] = False
class langchain.chat_models.ChatAnthropic(*, client=None, model='claude-v1', max_tokens_to_sample=256, temperature=None, top_k=None, top_p=None, streaming=False, default_request_timeout=None, anthropic_api_url=None, anthropic_api_key=None, HUMAN_PROMPT=None, AI_PROMPT=None, count_tokens=None, cache=None, verbose=None, callbacks=None, callback_manager=None, tags=None)[source]
Bases: langchain.chat_models.base.BaseChatModel, langchain.llms.anthropic._AnthropicCommon


Wrapper around Anthropic’s large language model.
To use, you should have the anthropic python package installed, and the
environment variable ANTHROPIC_API_KEY set with your API key, or pass
it as a named parameter to the constructor.
Example
import anthropic
from langchain.llms import Anthropic
model = ChatAnthropic(model="<model_name>", anthropic_api_key="my-api-key")
Parameters
client (Any) –
model (str) –
max_tokens_to_sample (int) –
temperature (Optional[float]) –
top_k (Optional[int]) –
top_p (Optional[float]) –
streaming (bool) –
default_request_timeout (Optional[Union[float, Tuple[float, float]]]) –
anthropic_api_url (Optional[str]) –
anthropic_api_key (Optional[str]) –
HUMAN_PROMPT (Optional[str]) –
AI_PROMPT (Optional[str]) –
count_tokens (Optional[Callable[[str], int]]) –
cache (Optional[bool]) –
verbose (bool) –
callbacks (Optional[Union[List[langchain.callbacks.base.BaseCallbackHandler], langchain.callbacks.base.BaseCallbackManager]]) –
callback_manager (Optional[langchain.callbacks.base.BaseCallbackManager]) –
tags (Optional[List[str]]) –
Return type
None
get_num_tokens(text)[source]
Calculate number of tokens.
Parameters
text (str) –
Return type
int
property lc_serializable: bool
Return whether or not the class is serializable.


property lc_serializable: bool
Return whether or not the class is serializable.
class langchain.chat_models.ChatGooglePalm(*, cache=None, verbose=None, callbacks=None, callback_manager=None, tags=None, client=None, model_name='models/chat-bison-001', google_api_key=None, temperature=None, top_p=None, top_k=None, n=1)[source]
Bases: langchain.chat_models.base.BaseChatModel, pydantic.main.BaseModel
Wrapper around Google’s PaLM Chat API.
To use you must have the google.generativeai Python package installed and
either:
The GOOGLE_API_KEY` environment varaible set with your API key, or
Pass your API key using the google_api_key kwarg to the ChatGoogle
constructor.
Example
from langchain.chat_models import ChatGooglePalm
chat = ChatGooglePalm()
Parameters
cache (Optional[bool]) –
verbose (bool) –
callbacks (Optional[Union[List[langchain.callbacks.base.BaseCallbackHandler], langchain.callbacks.base.BaseCallbackManager]]) –
callback_manager (Optional[langchain.callbacks.base.BaseCallbackManager]) –
tags (Optional[List[str]]) –
client (Any) –
model_name (str) –
google_api_key (Optional[str]) –
temperature (Optional[float]) –
top_p (Optional[float]) –
top_k (Optional[int]) –
n (int) –
Return type
None
attribute google_api_key: Optional[str] = None
attribute model_name: str = 'models/chat-bison-001'
Model name to use.
attribute n: int = 1
Number of chat completions to generate for each prompt. Note that the API may
not return the full n completions if duplicates are generated.


not return the full n completions if duplicates are generated.
attribute temperature: Optional[float] = None
Run inference with this temperature. Must by in the closed
interval [0.0, 1.0].
attribute top_k: Optional[int] = None
Decode using top-k sampling: consider the set of top_k most probable tokens.
Must be positive.
attribute top_p: Optional[float] = None
Decode using nucleus sampling: consider the smallest set of tokens whose
probability sum is at least top_p. Must be in the closed interval [0.0, 1.0].
class langchain.chat_models.ChatVertexAI(*, cache=None, verbose=None, callbacks=None, callback_manager=None, tags=None, client=None, model_name='chat-bison', temperature=0.0, max_output_tokens=128, top_p=0.95, top_k=40, stop=None, project=None, location='us-central1', credentials=None)[source]
Bases: langchain.llms.vertexai._VertexAICommon, langchain.chat_models.base.BaseChatModel
Wrapper around Vertex AI large language models.
Parameters
cache (Optional[bool]) –
verbose (bool) –
callbacks (Optional[Union[List[langchain.callbacks.base.BaseCallbackHandler], langchain.callbacks.base.BaseCallbackManager]]) –
callback_manager (Optional[langchain.callbacks.base.BaseCallbackManager]) –
tags (Optional[List[str]]) –
client (_LanguageModel) –
model_name (str) –
temperature (float) –
max_output_tokens (int) –
top_p (float) –
top_k (int) –
stop (Optional[List[str]]) –
project (Optional[str]) –
location (str) –
credentials (Any) –
Return type
None


location (str) –
credentials (Any) –
Return type
None
attribute model_name: str = 'chat-bison'
Model name to use.


Prompt Templates
Prompt template classes.
class langchain.prompts.AIMessagePromptTemplate(*, prompt, additional_kwargs=None)[source]
Bases: langchain.prompts.chat.BaseStringMessagePromptTemplate
Parameters
prompt (langchain.prompts.base.StringPromptTemplate) –
additional_kwargs (dict) –
Return type
None
format(**kwargs)[source]
To a BaseMessage.
Parameters
kwargs (Any) –
Return type
langchain.schema.BaseMessage
class langchain.prompts.BaseChatPromptTemplate(*, input_variables, output_parser=None, partial_variables=None)[source]
Bases: langchain.prompts.base.BasePromptTemplate, abc.ABC
Parameters
input_variables (List[str]) –
output_parser (Optional[langchain.schema.BaseOutputParser]) –
partial_variables (Mapping[str, Union[str, Callable[[], str]]]) –
Return type
None
format(**kwargs)[source]
Format the prompt with the inputs.
Parameters
kwargs (Any) – Any arguments to be passed to the prompt template.
Returns
A formatted string.
Return type
str
Example:
prompt.format(variable1="foo")
abstract format_messages(**kwargs)[source]
Format kwargs into a list of messages.
Parameters
kwargs (Any) –
Return type
List[langchain.schema.BaseMessage]
format_prompt(**kwargs)[source]
Create Chat Messages.
Parameters
kwargs (Any) –
Return type
langchain.schema.PromptValue
class langchain.prompts.BasePromptTemplate(*, input_variables, output_parser=None, partial_variables=None)[source]
Bases: langchain.load.serializable.Serializable, abc.ABC
Base class for all prompt templates, returning a prompt.
Parameters
input_variables (List[str]) –


Parameters
input_variables (List[str]) –
output_parser (Optional[langchain.schema.BaseOutputParser]) –
partial_variables (Mapping[str, Union[str, Callable[[], str]]]) –
Return type
None
attribute input_variables: List[str] [Required]
A list of the names of the variables the prompt template expects.
attribute output_parser: Optional[langchain.schema.BaseOutputParser] = None
How to parse the output of calling an LLM on this formatted prompt.
attribute partial_variables: Mapping[str, Union[str, Callable[[], str]]] [Optional]
dict(**kwargs)[source]
Return dictionary representation of prompt.
Parameters
kwargs (Any) –
Return type
Dict
abstract format(**kwargs)[source]
Format the prompt with the inputs.
Parameters
kwargs (Any) – Any arguments to be passed to the prompt template.
Returns
A formatted string.
Return type
str
Example:
prompt.format(variable1="foo")
abstract format_prompt(**kwargs)[source]
Create Chat Messages.
Parameters
kwargs (Any) –
Return type
langchain.schema.PromptValue
partial(**kwargs)[source]
Return a partial of the prompt template.
Parameters
kwargs (Union[str, Callable[[], str]]) –
Return type
langchain.prompts.base.BasePromptTemplate
save(file_path)[source]
Save the prompt.
Parameters
file_path (Union[pathlib.Path, str]) – Path to directory to save prompt to.
Return type
None
Example:
.. code-block:: python
prompt.save(file_path=”path/prompt.yaml”)
property lc_serializable: bool
Return whether or not the class is serializable.


property lc_serializable: bool
Return whether or not the class is serializable.
class langchain.prompts.ChatMessagePromptTemplate(*, prompt, additional_kwargs=None, role)[source]
Bases: langchain.prompts.chat.BaseStringMessagePromptTemplate
Parameters
prompt (langchain.prompts.base.StringPromptTemplate) –
additional_kwargs (dict) –
role (str) –
Return type
None
attribute role: str [Required]
format(**kwargs)[source]
To a BaseMessage.
Parameters
kwargs (Any) –
Return type
langchain.schema.BaseMessage
class langchain.prompts.ChatPromptTemplate(*, input_variables, output_parser=None, partial_variables=None, messages)[source]
Bases: langchain.prompts.chat.BaseChatPromptTemplate, abc.ABC
Parameters
input_variables (List[str]) –
output_parser (Optional[langchain.schema.BaseOutputParser]) –
partial_variables (Mapping[str, Union[str, Callable[[], str]]]) –
messages (List[Union[langchain.prompts.chat.BaseMessagePromptTemplate, langchain.schema.BaseMessage]]) –
Return type
None
attribute input_variables: List[str] [Required]
A list of the names of the variables the prompt template expects.
attribute messages: List[Union[BaseMessagePromptTemplate, BaseMessage]] [Required]
format(**kwargs)[source]
Format the prompt with the inputs.
Parameters
kwargs (Any) – Any arguments to be passed to the prompt template.
Returns
A formatted string.
Return type
str
Example:
prompt.format(variable1="foo")
format_messages(**kwargs)[source]
Format kwargs into a list of messages.
Parameters
kwargs (Any) –
Return type


Parameters
kwargs (Any) –
Return type
List[langchain.schema.BaseMessage]
classmethod from_messages(messages)[source]
Parameters
messages (Sequence[Union[langchain.prompts.chat.BaseMessagePromptTemplate, langchain.schema.BaseMessage]]) –
Return type
langchain.prompts.chat.ChatPromptTemplate
classmethod from_role_strings(string_messages)[source]
Parameters
string_messages (List[Tuple[str, str]]) –
Return type
langchain.prompts.chat.ChatPromptTemplate
classmethod from_strings(string_messages)[source]
Parameters
string_messages (List[Tuple[Type[langchain.prompts.chat.BaseMessagePromptTemplate], str]]) –
Return type
langchain.prompts.chat.ChatPromptTemplate
classmethod from_template(template, **kwargs)[source]
Parameters
template (str) –
kwargs (Any) –
Return type
langchain.prompts.chat.ChatPromptTemplate
partial(**kwargs)[source]
Return a partial of the prompt template.
Parameters
kwargs (Union[str, Callable[[], str]]) –
Return type
langchain.prompts.base.BasePromptTemplate
save(file_path)[source]
Save the prompt.
Parameters
file_path (Union[pathlib.Path, str]) – Path to directory to save prompt to.
Return type
None
Example:
.. code-block:: python
prompt.save(file_path=”path/prompt.yaml”)
class langchain.prompts.FewShotPromptTemplate(*, input_variables, output_parser=None, partial_variables=None, examples=None, example_selector=None, example_prompt, suffix, example_separator='\n\n', prefix='', template_format='f-string', validate_template=True)[source]
Bases: langchain.prompts.base.StringPromptTemplate
Prompt template that contains few shot examples.
Parameters
input_variables (List[str]) –


Prompt template that contains few shot examples.
Parameters
input_variables (List[str]) –
output_parser (Optional[langchain.schema.BaseOutputParser]) –
partial_variables (Mapping[str, Union[str, Callable[[], str]]]) –
examples (Optional[List[dict]]) –
example_selector (Optional[langchain.prompts.example_selector.base.BaseExampleSelector]) –
example_prompt (langchain.prompts.prompt.PromptTemplate) –
suffix (str) –
example_separator (str) –
prefix (str) –
template_format (str) –
validate_template (bool) –
Return type
None
attribute example_prompt: langchain.prompts.prompt.PromptTemplate [Required]
PromptTemplate used to format an individual example.
attribute example_selector: Optional[langchain.prompts.example_selector.base.BaseExampleSelector] = None
ExampleSelector to choose the examples to format into the prompt.
Either this or examples should be provided.
attribute example_separator: str = '\n\n'
String separator used to join the prefix, the examples, and suffix.
attribute examples: Optional[List[dict]] = None
Examples to format into the prompt.
Either this or example_selector should be provided.
attribute input_variables: List[str] [Required]
A list of the names of the variables the prompt template expects.
attribute prefix: str = ''
A prompt template string to put before the examples.
attribute suffix: str [Required]
A prompt template string to put after the examples.
attribute template_format: str = 'f-string'
The format of the prompt template. Options are: ‘f-string’, ‘jinja2’.
attribute validate_template: bool = True
Whether or not to try validating the template.


attribute validate_template: bool = True
Whether or not to try validating the template.
dict(**kwargs)[source]
Return a dictionary of the prompt.
Parameters
kwargs (Any) –
Return type
Dict
format(**kwargs)[source]
Format the prompt with the inputs.
Parameters
kwargs (Any) – Any arguments to be passed to the prompt template.
Returns
A formatted string.
Return type
str
Example:
prompt.format(variable1="foo")
property lc_serializable: bool
Return whether or not the class is serializable.
class langchain.prompts.FewShotPromptWithTemplates(*, input_variables, output_parser=None, partial_variables=None, examples=None, example_selector=None, example_prompt, suffix, example_separator='\n\n', prefix=None, template_format='f-string', validate_template=True)[source]
Bases: langchain.prompts.base.StringPromptTemplate
Prompt template that contains few shot examples.
Parameters
input_variables (List[str]) –
output_parser (Optional[langchain.schema.BaseOutputParser]) –
partial_variables (Mapping[str, Union[str, Callable[[], str]]]) –
examples (Optional[List[dict]]) –
example_selector (Optional[langchain.prompts.example_selector.base.BaseExampleSelector]) –
example_prompt (langchain.prompts.prompt.PromptTemplate) –
suffix (langchain.prompts.base.StringPromptTemplate) –
example_separator (str) –
prefix (Optional[langchain.prompts.base.StringPromptTemplate]) –
template_format (str) –
validate_template (bool) –
Return type
None
attribute example_prompt: langchain.prompts.prompt.PromptTemplate [Required]
PromptTemplate used to format an individual example.


PromptTemplate used to format an individual example.
attribute example_selector: Optional[langchain.prompts.example_selector.base.BaseExampleSelector] = None
ExampleSelector to choose the examples to format into the prompt.
Either this or examples should be provided.
attribute example_separator: str = '\n\n'
String separator used to join the prefix, the examples, and suffix.
attribute examples: Optional[List[dict]] = None
Examples to format into the prompt.
Either this or example_selector should be provided.
attribute input_variables: List[str] [Required]
A list of the names of the variables the prompt template expects.
attribute prefix: Optional[langchain.prompts.base.StringPromptTemplate] = None
A PromptTemplate to put before the examples.
attribute suffix: langchain.prompts.base.StringPromptTemplate [Required]
A PromptTemplate to put after the examples.
attribute template_format: str = 'f-string'
The format of the prompt template. Options are: ‘f-string’, ‘jinja2’.
attribute validate_template: bool = True
Whether or not to try validating the template.
dict(**kwargs)[source]
Return a dictionary of the prompt.
Parameters
kwargs (Any) –
Return type
Dict
format(**kwargs)[source]
Format the prompt with the inputs.
Parameters
kwargs (Any) – Any arguments to be passed to the prompt template.
Returns
A formatted string.
Return type
str
Example:
prompt.format(variable1="foo")
class langchain.prompts.HumanMessagePromptTemplate(*, prompt, additional_kwargs=None)[source]
Bases: langchain.prompts.chat.BaseStringMessagePromptTemplate
Parameters
prompt (langchain.prompts.base.StringPromptTemplate) –
additional_kwargs (dict) –


additional_kwargs (dict) –
Return type
None
format(**kwargs)[source]
To a BaseMessage.
Parameters
kwargs (Any) –
Return type
langchain.schema.BaseMessage
class langchain.prompts.LengthBasedExampleSelector(*, examples, example_prompt, get_text_length=<function _get_length_based>, max_length=2048, example_text_lengths=[])[source]
Bases: langchain.prompts.example_selector.base.BaseExampleSelector, pydantic.main.BaseModel
Select examples based on length.
Parameters
examples (List[dict]) –
example_prompt (langchain.prompts.prompt.PromptTemplate) –
get_text_length (Callable[[str], int]) –
max_length (int) –
example_text_lengths (List[int]) –
Return type
None
attribute example_prompt: langchain.prompts.prompt.PromptTemplate [Required]
Prompt template used to format the examples.
attribute examples: List[dict] [Required]
A list of the examples that the prompt template expects.
attribute get_text_length: Callable[[str], int] = <function _get_length_based>
Function to measure prompt length. Defaults to word count.
attribute max_length: int = 2048
Max length for the prompt, beyond which examples are cut.
add_example(example)[source]
Add new example to list.
Parameters
example (Dict[str, str]) –
Return type
None
select_examples(input_variables)[source]
Select which examples to use based on the input lengths.
Parameters
input_variables (Dict[str, str]) –
Return type
List[dict]


input_variables (Dict[str, str]) –
Return type
List[dict]
class langchain.prompts.MaxMarginalRelevanceExampleSelector(*, vectorstore, k=4, example_keys=None, input_keys=None, fetch_k=20)[source]
Bases: langchain.prompts.example_selector.semantic_similarity.SemanticSimilarityExampleSelector
ExampleSelector that selects examples based on Max Marginal Relevance.
This was shown to improve performance in this paper:
https://arxiv.org/pdf/2211.13892.pdf
Parameters
vectorstore (langchain.vectorstores.base.VectorStore) –
k (int) –
example_keys (Optional[List[str]]) –
input_keys (Optional[List[str]]) –
fetch_k (int) –
Return type
None
attribute example_keys: Optional[List[str]] = None
Optional keys to filter examples to.
attribute fetch_k: int = 20
Number of examples to fetch to rerank.
attribute input_keys: Optional[List[str]] = None
Optional keys to filter input to. If provided, the search is based on
the input variables instead of all variables.
attribute k: int = 4
Number of examples to select.
attribute vectorstore: langchain.vectorstores.base.VectorStore [Required]
VectorStore than contains information about examples.
classmethod from_examples(examples, embeddings, vectorstore_cls, k=4, input_keys=None, fetch_k=20, **vectorstore_cls_kwargs)[source]
Create k-shot example selector using example list and embeddings.
Reshuffles examples dynamically based on query similarity.
Parameters
examples (List[dict]) – List of examples to use in the prompt.


Parameters
examples (List[dict]) – List of examples to use in the prompt.
embeddings (langchain.embeddings.base.Embeddings) – An iniialized embedding API interface, e.g. OpenAIEmbeddings().
vectorstore_cls (Type[langchain.vectorstores.base.VectorStore]) – A vector store DB interface class, e.g. FAISS.
k (int) – Number of examples to select
input_keys (Optional[List[str]]) – If provided, the search is based on the input variables
instead of all variables.
vectorstore_cls_kwargs (Any) – optional kwargs containing url for vector store
fetch_k (int) –
Returns
The ExampleSelector instantiated, backed by a vector store.
Return type
langchain.prompts.example_selector.semantic_similarity.MaxMarginalRelevanceExampleSelector
select_examples(input_variables)[source]
Select which examples to use based on semantic similarity.
Parameters
input_variables (Dict[str, str]) –
Return type
List[dict]
class langchain.prompts.MessagesPlaceholder(*, variable_name)[source]
Bases: langchain.prompts.chat.BaseMessagePromptTemplate
Prompt template that assumes variable is already list of messages.
Parameters
variable_name (str) –
Return type
None
attribute variable_name: str [Required]
format_messages(**kwargs)[source]
To a BaseMessage.
Parameters
kwargs (Any) –
Return type
List[langchain.schema.BaseMessage]
property input_variables: List[str]
Input variables for this prompt template.
class langchain.prompts.NGramOverlapExampleSelector(*, examples, example_prompt, threshold=- 1.0)[source]
Bases: langchain.prompts.example_selector.base.BaseExampleSelector, pydantic.main.BaseModel


Select and order examples based on ngram overlap score (sentence_bleu score).
https://www.nltk.org/_modules/nltk/translate/bleu_score.html
https://aclanthology.org/P02-1040.pdf
Parameters
examples (List[dict]) –
example_prompt (langchain.prompts.prompt.PromptTemplate) –
threshold (float) –
Return type
None
attribute example_prompt: langchain.prompts.prompt.PromptTemplate [Required]
Prompt template used to format the examples.
attribute examples: List[dict] [Required]
A list of the examples that the prompt template expects.
attribute threshold: float = -1.0
Threshold at which algorithm stops. Set to -1.0 by default.
For negative threshold:
select_examples sorts examples by ngram_overlap_score, but excludes none.
For threshold greater than 1.0:
select_examples excludes all examples, and returns an empty list.
For threshold equal to 0.0:
select_examples sorts examples by ngram_overlap_score,
and excludes examples with no ngram overlap with input.
add_example(example)[source]
Add new example to list.
Parameters
example (Dict[str, str]) –
Return type
None
select_examples(input_variables)[source]
Return list of examples sorted by ngram_overlap_score with input.
Descending order.
Excludes any examples with ngram_overlap_score less than or equal to threshold.
Parameters
input_variables (Dict[str, str]) –
Return type
List[dict]
class langchain.prompts.PipelinePromptTemplate(*, input_variables, output_parser=None, partial_variables=None, final_prompt, pipeline_prompts)[source]
Bases: langchain.prompts.base.BasePromptTemplate
A prompt template for composing multiple prompts together.


A prompt template for composing multiple prompts together.
This can be useful when you want to reuse parts of prompts.
A PipelinePrompt consists of two main parts:
final_prompt: This is the final prompt that is returned
pipeline_prompts: This is a list of tuples, consistingof a string (name) and a Prompt Template.
Each PromptTemplate will be formatted and then passed
to future prompt templates as a variable with
the same name as name
Parameters
input_variables (List[str]) –
output_parser (Optional[langchain.schema.BaseOutputParser]) –
partial_variables (Mapping[str, Union[str, Callable[[], str]]]) –
final_prompt (langchain.prompts.base.BasePromptTemplate) –
pipeline_prompts (List[Tuple[str, langchain.prompts.base.BasePromptTemplate]]) –
Return type
None
attribute final_prompt: langchain.prompts.base.BasePromptTemplate [Required]
attribute pipeline_prompts: List[Tuple[str, langchain.prompts.base.BasePromptTemplate]] [Required]
format(**kwargs)[source]
Format the prompt with the inputs.
Parameters
kwargs (Any) – Any arguments to be passed to the prompt template.
Returns
A formatted string.
Return type
str
Example:
prompt.format(variable1="foo")
format_prompt(**kwargs)[source]
Create Chat Messages.
Parameters
kwargs (Any) –
Return type
langchain.schema.PromptValue
langchain.prompts.Prompt
alias of langchain.prompts.prompt.PromptTemplate
class langchain.prompts.PromptTemplate(*, input_variables, output_parser=None, partial_variables=None, template, template_format='f-string', validate_template=True)[source]
Bases: langchain.prompts.base.StringPromptTemplate
Schema to represent a prompt for an LLM.
Example


Schema to represent a prompt for an LLM.
Example
from langchain import PromptTemplate
prompt = PromptTemplate(input_variables=["foo"], template="Say {foo}")
Parameters
input_variables (List[str]) –
output_parser (Optional[langchain.schema.BaseOutputParser]) –
partial_variables (Mapping[str, Union[str, Callable[[], str]]]) –
template (str) –
template_format (str) –
validate_template (bool) –
Return type
None
attribute input_variables: List[str] [Required]
A list of the names of the variables the prompt template expects.
attribute template: str [Required]
The prompt template.
attribute template_format: str = 'f-string'
The format of the prompt template. Options are: ‘f-string’, ‘jinja2’.
attribute validate_template: bool = True
Whether or not to try validating the template.
format(**kwargs)[source]
Format the prompt with the inputs.
Parameters
kwargs (Any) – Any arguments to be passed to the prompt template.
Returns
A formatted string.
Return type
str
Example:
prompt.format(variable1="foo")
classmethod from_examples(examples, suffix, input_variables, example_separator='\n\n', prefix='', **kwargs)[source]
Take examples in list format with prefix and suffix to create a prompt.
Intended to be used as a way to dynamically create a prompt from examples.
Parameters
examples (List[str]) – List of examples to use in the prompt.
suffix (str) – String to go after the list of examples. Should generally
set up the user’s input.
input_variables (List[str]) – A list of variable names the final prompt template
will expect.
example_separator (str) – The separator to use in between examples. Defaults


will expect.
example_separator (str) – The separator to use in between examples. Defaults
to two new line characters.
prefix (str) – String that should go before any examples. Generally includes
examples. Default to an empty string.
kwargs (Any) –
Returns
The final prompt generated.
Return type
langchain.prompts.prompt.PromptTemplate
classmethod from_file(template_file, input_variables, **kwargs)[source]
Load a prompt from a file.
Parameters
template_file (Union[str, pathlib.Path]) – The path to the file containing the prompt template.
input_variables (List[str]) – A list of variable names the final prompt template
will expect.
kwargs (Any) –
Returns
The prompt loaded from the file.
Return type
langchain.prompts.prompt.PromptTemplate
classmethod from_template(template, **kwargs)[source]
Load a prompt template from a template.
Parameters
template (str) –
kwargs (Any) –
Return type
langchain.prompts.prompt.PromptTemplate
property lc_attributes: Dict[str, Any]
Return a list of attribute names that should be included in the
serialized kwargs. These attributes must be accepted by the
constructor.
class langchain.prompts.SemanticSimilarityExampleSelector(*, vectorstore, k=4, example_keys=None, input_keys=None)[source]
Bases: langchain.prompts.example_selector.base.BaseExampleSelector, pydantic.main.BaseModel
Example selector that selects examples based on SemanticSimilarity.
Parameters
vectorstore (langchain.vectorstores.base.VectorStore) –
k (int) –
example_keys (Optional[List[str]]) –
input_keys (Optional[List[str]]) –
Return type
None
attribute example_keys: Optional[List[str]] = None


Return type
None
attribute example_keys: Optional[List[str]] = None
Optional keys to filter examples to.
attribute input_keys: Optional[List[str]] = None
Optional keys to filter input to. If provided, the search is based on
the input variables instead of all variables.
attribute k: int = 4
Number of examples to select.
attribute vectorstore: langchain.vectorstores.base.VectorStore [Required]
VectorStore than contains information about examples.
add_example(example)[source]
Add new example to vectorstore.
Parameters
example (Dict[str, str]) –
Return type
str
classmethod from_examples(examples, embeddings, vectorstore_cls, k=4, input_keys=None, **vectorstore_cls_kwargs)[source]
Create k-shot example selector using example list and embeddings.
Reshuffles examples dynamically based on query similarity.
Parameters
examples (List[dict]) – List of examples to use in the prompt.
embeddings (langchain.embeddings.base.Embeddings) – An initialized embedding API interface, e.g. OpenAIEmbeddings().
vectorstore_cls (Type[langchain.vectorstores.base.VectorStore]) – A vector store DB interface class, e.g. FAISS.
k (int) – Number of examples to select
input_keys (Optional[List[str]]) – If provided, the search is based on the input variables
instead of all variables.
vectorstore_cls_kwargs (Any) – optional kwargs containing url for vector store
Returns
The ExampleSelector instantiated, backed by a vector store.
Return type
langchain.prompts.example_selector.semantic_similarity.SemanticSimilarityExampleSelector
select_examples(input_variables)[source]
Select which examples to use based on semantic similarity.
Parameters
input_variables (Dict[str, str]) –
Return type
List[dict]


input_variables (Dict[str, str]) –
Return type
List[dict]
class langchain.prompts.StringPromptTemplate(*, input_variables, output_parser=None, partial_variables=None)[source]
Bases: langchain.prompts.base.BasePromptTemplate, abc.ABC
String prompt should expose the format method, returning a prompt.
Parameters
input_variables (List[str]) –
output_parser (Optional[langchain.schema.BaseOutputParser]) –
partial_variables (Mapping[str, Union[str, Callable[[], str]]]) –
Return type
None
format_prompt(**kwargs)[source]
Create Chat Messages.
Parameters
kwargs (Any) –
Return type
langchain.schema.PromptValue
class langchain.prompts.SystemMessagePromptTemplate(*, prompt, additional_kwargs=None)[source]
Bases: langchain.prompts.chat.BaseStringMessagePromptTemplate
Parameters
prompt (langchain.prompts.base.StringPromptTemplate) –
additional_kwargs (dict) –
Return type
None
format(**kwargs)[source]
To a BaseMessage.
Parameters
kwargs (Any) –
Return type
langchain.schema.BaseMessage
langchain.prompts.load_prompt(path)[source]
Unified method for loading a prompt from LangChainHub or local fs.
Parameters
path (Union[str, pathlib.Path]) –
Return type
langchain.prompts.base.BasePromptTemplate


Example Selector
Logic for selecting examples to include in prompts.
class langchain.prompts.example_selector.LengthBasedExampleSelector(*, examples, example_prompt, get_text_length=<function _get_length_based>, max_length=2048, example_text_lengths=[])[source]
Bases: langchain.prompts.example_selector.base.BaseExampleSelector, pydantic.main.BaseModel
Select examples based on length.
Parameters
examples (List[dict]) –
example_prompt (langchain.prompts.prompt.PromptTemplate) –
get_text_length (Callable[[str], int]) –
max_length (int) –
example_text_lengths (List[int]) –
Return type
None
attribute example_prompt: langchain.prompts.prompt.PromptTemplate [Required]
Prompt template used to format the examples.
attribute examples: List[dict] [Required]
A list of the examples that the prompt template expects.
attribute get_text_length: Callable[[str], int] = <function _get_length_based>
Function to measure prompt length. Defaults to word count.
attribute max_length: int = 2048
Max length for the prompt, beyond which examples are cut.
add_example(example)[source]
Add new example to list.
Parameters
example (Dict[str, str]) –
Return type
None
select_examples(input_variables)[source]
Select which examples to use based on the input lengths.
Parameters
input_variables (Dict[str, str]) –
Return type
List[dict]
class langchain.prompts.example_selector.MaxMarginalRelevanceExampleSelector(*, vectorstore, k=4, example_keys=None, input_keys=None, fetch_k=20)[source]
Bases: langchain.prompts.example_selector.semantic_similarity.SemanticSimilarityExampleSelector


Bases: langchain.prompts.example_selector.semantic_similarity.SemanticSimilarityExampleSelector
ExampleSelector that selects examples based on Max Marginal Relevance.
This was shown to improve performance in this paper:
https://arxiv.org/pdf/2211.13892.pdf
Parameters
vectorstore (langchain.vectorstores.base.VectorStore) –
k (int) –
example_keys (Optional[List[str]]) –
input_keys (Optional[List[str]]) –
fetch_k (int) –
Return type
None
attribute fetch_k: int = 20
Number of examples to fetch to rerank.
classmethod from_examples(examples, embeddings, vectorstore_cls, k=4, input_keys=None, fetch_k=20, **vectorstore_cls_kwargs)[source]
Create k-shot example selector using example list and embeddings.
Reshuffles examples dynamically based on query similarity.
Parameters
examples (List[dict]) – List of examples to use in the prompt.
embeddings (langchain.embeddings.base.Embeddings) – An iniialized embedding API interface, e.g. OpenAIEmbeddings().
vectorstore_cls (Type[langchain.vectorstores.base.VectorStore]) – A vector store DB interface class, e.g. FAISS.
k (int) – Number of examples to select
input_keys (Optional[List[str]]) – If provided, the search is based on the input variables
instead of all variables.
vectorstore_cls_kwargs (Any) – optional kwargs containing url for vector store
fetch_k (int) –
Returns
The ExampleSelector instantiated, backed by a vector store.
Return type
langchain.prompts.example_selector.semantic_similarity.MaxMarginalRelevanceExampleSelector
select_examples(input_variables)[source]
Select which examples to use based on semantic similarity.
Parameters
input_variables (Dict[str, str]) –


Parameters
input_variables (Dict[str, str]) –
Return type
List[dict]
class langchain.prompts.example_selector.NGramOverlapExampleSelector(*, examples, example_prompt, threshold=- 1.0)[source]
Bases: langchain.prompts.example_selector.base.BaseExampleSelector, pydantic.main.BaseModel
Select and order examples based on ngram overlap score (sentence_bleu score).
https://www.nltk.org/_modules/nltk/translate/bleu_score.html
https://aclanthology.org/P02-1040.pdf
Parameters
examples (List[dict]) –
example_prompt (langchain.prompts.prompt.PromptTemplate) –
threshold (float) –
Return type
None
attribute example_prompt: langchain.prompts.prompt.PromptTemplate [Required]
Prompt template used to format the examples.
attribute examples: List[dict] [Required]
A list of the examples that the prompt template expects.
attribute threshold: float = -1.0
Threshold at which algorithm stops. Set to -1.0 by default.
For negative threshold:
select_examples sorts examples by ngram_overlap_score, but excludes none.
For threshold greater than 1.0:
select_examples excludes all examples, and returns an empty list.
For threshold equal to 0.0:
select_examples sorts examples by ngram_overlap_score,
and excludes examples with no ngram overlap with input.
add_example(example)[source]
Add new example to list.
Parameters
example (Dict[str, str]) –
Return type
None
select_examples(input_variables)[source]
Return list of examples sorted by ngram_overlap_score with input.
Descending order.
Excludes any examples with ngram_overlap_score less than or equal to threshold.
Parameters


Excludes any examples with ngram_overlap_score less than or equal to threshold.
Parameters
input_variables (Dict[str, str]) –
Return type
List[dict]
class langchain.prompts.example_selector.SemanticSimilarityExampleSelector(*, vectorstore, k=4, example_keys=None, input_keys=None)[source]
Bases: langchain.prompts.example_selector.base.BaseExampleSelector, pydantic.main.BaseModel
Example selector that selects examples based on SemanticSimilarity.
Parameters
vectorstore (langchain.vectorstores.base.VectorStore) –
k (int) –
example_keys (Optional[List[str]]) –
input_keys (Optional[List[str]]) –
Return type
None
attribute example_keys: Optional[List[str]] = None
Optional keys to filter examples to.
attribute input_keys: Optional[List[str]] = None
Optional keys to filter input to. If provided, the search is based on
the input variables instead of all variables.
attribute k: int = 4
Number of examples to select.
attribute vectorstore: langchain.vectorstores.base.VectorStore [Required]
VectorStore than contains information about examples.
add_example(example)[source]
Add new example to vectorstore.
Parameters
example (Dict[str, str]) –
Return type
str
classmethod from_examples(examples, embeddings, vectorstore_cls, k=4, input_keys=None, **vectorstore_cls_kwargs)[source]
Create k-shot example selector using example list and embeddings.
Reshuffles examples dynamically based on query similarity.
Parameters
examples (List[dict]) – List of examples to use in the prompt.
embeddings (langchain.embeddings.base.Embeddings) – An initialized embedding API interface, e.g. OpenAIEmbeddings().


vectorstore_cls (Type[langchain.vectorstores.base.VectorStore]) – A vector store DB interface class, e.g. FAISS.
k (int) – Number of examples to select
input_keys (Optional[List[str]]) – If provided, the search is based on the input variables
instead of all variables.
vectorstore_cls_kwargs (Any) – optional kwargs containing url for vector store
Returns
The ExampleSelector instantiated, backed by a vector store.
Return type
langchain.prompts.example_selector.semantic_similarity.SemanticSimilarityExampleSelector
select_examples(input_variables)[source]
Select which examples to use based on semantic similarity.
Parameters
input_variables (Dict[str, str]) –
Return type
List[dict]


Document Transformers
Transform documents
langchain.document_transformers.get_stateful_documents(documents)[source]
Convert a list of documents to a list of documents with state.
Parameters
documents (Sequence[langchain.schema.Document]) – The documents to convert.
Returns
A list of documents with state.
Return type
Sequence[langchain.document_transformers._DocumentWithState]
class langchain.document_transformers.EmbeddingsRedundantFilter(*, embeddings, similarity_fn=<function cosine_similarity>, similarity_threshold=0.95)[source]
Bases: langchain.schema.BaseDocumentTransformer, pydantic.main.BaseModel
Filter that drops redundant documents by comparing their embeddings.
Parameters
embeddings (langchain.embeddings.base.Embeddings) –
similarity_fn (Callable) –
similarity_threshold (float) –
Return type
None
attribute embeddings: langchain.embeddings.base.Embeddings [Required]
Embeddings to use for embedding document contents.
attribute similarity_fn: Callable = <function cosine_similarity>
Similarity function for comparing documents. Function expected to take as input
two matrices (List[List[float]]) and return a matrix of scores where higher values
indicate greater similarity.
attribute similarity_threshold: float = 0.95
Threshold for determining when two documents are similar enough
to be considered redundant.
async atransform_documents(documents, **kwargs)[source]
Asynchronously transform a list of documents.
Parameters
documents (Sequence[langchain.schema.Document]) –
kwargs (Any) –
Return type
Sequence[langchain.schema.Document]
transform_documents(documents, **kwargs)[source]
Filter down documents.
Parameters
documents (Sequence[langchain.schema.Document]) –
kwargs (Any) –
Return type
Sequence[langchain.schema.Document]


kwargs (Any) –
Return type
Sequence[langchain.schema.Document]
Text Splitters
Functionality for splitting text.
class langchain.text_splitter.TextSplitter(chunk_size=4000, chunk_overlap=200, length_function=<built-in function len>, keep_separator=False, add_start_index=False)[source]
Bases: langchain.schema.BaseDocumentTransformer, abc.ABC
Interface for splitting text into chunks.
Parameters
chunk_size (int) –
chunk_overlap (int) –
length_function (Callable[[str], int]) –
keep_separator (bool) –
add_start_index (bool) –
Return type
None
abstract split_text(text)[source]
Split text into multiple components.
Parameters
text (str) –
Return type
List[str]
create_documents(texts, metadatas=None)[source]
Create documents from a list of texts.
Parameters
texts (List[str]) –
metadatas (Optional[List[dict]]) –
Return type
List[langchain.schema.Document]
split_documents(documents)[source]
Split documents.
Parameters
documents (Iterable[langchain.schema.Document]) –
Return type
List[langchain.schema.Document]
classmethod from_huggingface_tokenizer(tokenizer, **kwargs)[source]
Text splitter that uses HuggingFace tokenizer to count length.
Parameters
tokenizer (Any) –
kwargs (Any) –
Return type
langchain.text_splitter.TextSplitter
classmethod from_tiktoken_encoder(encoding_name='gpt2', model_name=None, allowed_special={}, disallowed_special='all', **kwargs)[source]
Text splitter that uses tiktoken encoder to count length.
Parameters
encoding_name (str) –
model_name (Optional[str]) –


Parameters
encoding_name (str) –
model_name (Optional[str]) –
allowed_special (Union[Literal['all'], typing.AbstractSet[str]]) –
disallowed_special (Union[Literal['all'], typing.Collection[str]]) –
kwargs (Any) –
Return type
langchain.text_splitter.TS
transform_documents(documents, **kwargs)[source]
Transform sequence of documents by splitting them.
Parameters
documents (Sequence[langchain.schema.Document]) –
kwargs (Any) –
Return type
Sequence[langchain.schema.Document]
async atransform_documents(documents, **kwargs)[source]
Asynchronously transform a sequence of documents by splitting them.
Parameters
documents (Sequence[langchain.schema.Document]) –
kwargs (Any) –
Return type
Sequence[langchain.schema.Document]
class langchain.text_splitter.CharacterTextSplitter(separator='\n\n', **kwargs)[source]
Bases: langchain.text_splitter.TextSplitter
Implementation of splitting text that looks at characters.
Parameters
separator (str) –
kwargs (Any) –
Return type
None
split_text(text)[source]
Split incoming text and return chunks.
Parameters
text (str) –
Return type
List[str]
class langchain.text_splitter.LineType[source]
Bases: TypedDict
Line type as typed dict.
metadata: Dict[str, str]
content: str
class langchain.text_splitter.HeaderType[source]
Bases: TypedDict
Header type as typed dict.
level: int
name: str
data: str
class langchain.text_splitter.MarkdownHeaderTextSplitter(headers_to_split_on, return_each_line=False)[source]
Bases: object


Bases: object
Implementation of splitting markdown files based on specified headers.
Parameters
headers_to_split_on (List[Tuple[str, str]]) –
return_each_line (bool) –
aggregate_lines_to_chunks(lines)[source]
Combine lines with common metadata into chunks
:param lines: Line of text / associated header metadata
Parameters
lines (List[langchain.text_splitter.LineType]) –
Return type
List[langchain.schema.Document]
split_text(text)[source]
Split markdown file
:param text: Markdown file
Parameters
text (str) –
Return type
List[langchain.schema.Document]
class langchain.text_splitter.Tokenizer(chunk_overlap: 'int', tokens_per_chunk: 'int', decode: 'Callable[[list[int]], str]', encode: 'Callable[[str], List[int]]')[source]
Bases: object
Parameters
chunk_overlap (int) –
tokens_per_chunk (int) –
decode (Callable[[list[int]], str]) –
encode (Callable[[str], List[int]]) –
Return type
None
chunk_overlap: int
tokens_per_chunk: int
decode: Callable[[list[int]], str]
encode: Callable[[str], List[int]]
langchain.text_splitter.split_text_on_tokens(*, text, tokenizer)[source]
Split incoming text and return chunks.
Parameters
text (str) –
tokenizer (langchain.text_splitter.Tokenizer) –
Return type
List[str]
class langchain.text_splitter.TokenTextSplitter(encoding_name='gpt2', model_name=None, allowed_special={}, disallowed_special='all', **kwargs)[source]
Bases: langchain.text_splitter.TextSplitter
Implementation of splitting text that looks at tokens.
Parameters


Implementation of splitting text that looks at tokens.
Parameters
encoding_name (str) –
model_name (Optional[str]) –
allowed_special (Union[Literal['all'], AbstractSet[str]]) –
disallowed_special (Union[Literal['all'], Collection[str]]) –
kwargs (Any) –
Return type
None
split_text(text)[source]
Split text into multiple components.
Parameters
text (str) –
Return type
List[str]
class langchain.text_splitter.SentenceTransformersTokenTextSplitter(chunk_overlap=50, model_name='sentence-transformers/all-mpnet-base-v2', tokens_per_chunk=None, **kwargs)[source]
Bases: langchain.text_splitter.TextSplitter
Implementation of splitting text that looks at tokens.
Parameters
chunk_overlap (int) –
model_name (str) –
tokens_per_chunk (Optional[int]) –
kwargs (Any) –
Return type
None
split_text(text)[source]
Split text into multiple components.
Parameters
text (str) –
Return type
List[str]
count_tokens(*, text)[source]
Parameters
text (str) –
Return type
int
class langchain.text_splitter.Language(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)[source]
Bases: str, enum.Enum
CPP = 'cpp'
GO = 'go'
JAVA = 'java'
JS = 'js'
PHP = 'php'
PROTO = 'proto'
PYTHON = 'python'
RST = 'rst'
RUBY = 'ruby'
RUST = 'rust'


RUBY = 'ruby'
RUST = 'rust'
SCALA = 'scala'
SWIFT = 'swift'
MARKDOWN = 'markdown'
LATEX = 'latex'
HTML = 'html'
SOL = 'sol'
class langchain.text_splitter.RecursiveCharacterTextSplitter(separators=None, keep_separator=True, **kwargs)[source]
Bases: langchain.text_splitter.TextSplitter
Implementation of splitting text that looks at characters.
Recursively tries to split by different characters to find one
that works.
Parameters
separators (Optional[List[str]]) –
keep_separator (bool) –
kwargs (Any) –
Return type
None
split_text(text)[source]
Split text into multiple components.
Parameters
text (str) –
Return type
List[str]
classmethod from_language(language, **kwargs)[source]
Parameters
language (langchain.text_splitter.Language) –
kwargs (Any) –
Return type
langchain.text_splitter.RecursiveCharacterTextSplitter
static get_separators_for_language(language)[source]
Parameters
language (langchain.text_splitter.Language) –
Return type
List[str]
class langchain.text_splitter.NLTKTextSplitter(separator='\n\n', **kwargs)[source]
Bases: langchain.text_splitter.TextSplitter
Implementation of splitting text that looks at sentences using NLTK.
Parameters
separator (str) –
kwargs (Any) –
Return type
None
split_text(text)[source]
Split incoming text and return chunks.
Parameters
text (str) –
Return type
List[str]


Parameters
text (str) –
Return type
List[str]
class langchain.text_splitter.SpacyTextSplitter(separator='\n\n', pipeline='en_core_web_sm', **kwargs)[source]
Bases: langchain.text_splitter.TextSplitter
Implementation of splitting text that looks at sentences using Spacy.
Parameters
separator (str) –
pipeline (str) –
kwargs (Any) –
Return type
None
split_text(text)[source]
Split incoming text and return chunks.
Parameters
text (str) –
Return type
List[str]
class langchain.text_splitter.PythonCodeTextSplitter(**kwargs)[source]
Bases: langchain.text_splitter.RecursiveCharacterTextSplitter
Attempts to split the text along Python syntax.
Parameters
kwargs (Any) –
Return type
None
class langchain.text_splitter.MarkdownTextSplitter(**kwargs)[source]
Bases: langchain.text_splitter.RecursiveCharacterTextSplitter
Attempts to split the text along Markdown-formatted headings.
Parameters
kwargs (Any) –
Return type
None
class langchain.text_splitter.LatexTextSplitter(**kwargs)[source]
Bases: langchain.text_splitter.RecursiveCharacterTextSplitter
Attempts to split the text along Latex-formatted layout elements.
Parameters
kwargs (Any) –
Return type
None


Agents
Interface for agents.
class langchain.agents.Agent(*, llm_chain, output_parser, allowed_tools=None)[source]
Bases: langchain.agents.agent.BaseSingleActionAgent
Class responsible for calling the language model and deciding the action.
This is driven by an LLMChain. The prompt in the LLMChain MUST include
a variable called “agent_scratchpad” where the agent can put its
intermediary work.
Parameters
llm_chain (langchain.chains.llm.LLMChain) –
output_parser (langchain.agents.agent.AgentOutputParser) –
allowed_tools (Optional[List[str]]) –
Return type
None
attribute allowed_tools: Optional[List[str]] = None
attribute llm_chain: langchain.chains.llm.LLMChain [Required]
attribute output_parser: langchain.agents.agent.AgentOutputParser [Required]
async aplan(intermediate_steps, callbacks=None, **kwargs)[source]
Given input, decided what to do.
Parameters
intermediate_steps (List[Tuple[langchain.schema.AgentAction, str]]) – Steps the LLM has taken to date,
along with observations
callbacks (Optional[Union[List[langchain.callbacks.base.BaseCallbackHandler], langchain.callbacks.base.BaseCallbackManager]]) – Callbacks to run.
**kwargs – User inputs.
kwargs (Any) –
Returns
Action specifying what tool to use.
Return type
Union[langchain.schema.AgentAction, langchain.schema.AgentFinish]
abstract classmethod create_prompt(tools)[source]
Create a prompt for this class.
Parameters
tools (Sequence[langchain.tools.base.BaseTool]) –
Return type
langchain.prompts.base.BasePromptTemplate
dict(**kwargs)[source]
Return dictionary representation of agent.
Parameters