viruPVS/langchain-docs huggingface dataset:
Instantiate a prompt cache using Momento as a backend.
Note: to instantiate the cache client passed to MomentoCache,
you must have a Momento account. See https://gomomento.com/.
Parameters
cache_client (CacheClient) – The Momento cache client.
cache_name (str) – The name of the cache to use to store the data.
ttl (Optional[timedelta], optional) – The time to live for the cache items.
Defaults to None, ie use the client default TTL.
ensure_cache_exists (bool, optional) – Create the cache if it doesn’t
exist. Defaults to True.
Raises
ImportError – Momento python package is not installed.
TypeError – cache_client is not of type momento.CacheClientObject
ValueError – ttl is non-null and non-negative
clear(**kwargs: Any) → None[source]¶
Clear the cache.
Raises
SdkException – Momento service or network error
classmethod from_client_params(cache_name: str, ttl: timedelta, *, configuration: Optional[momento.config.Configuration] = None, api_key: Optional[str] = None, auth_token: Optional[str] = None, **kwargs: Any) → MomentoCache[source]¶
Construct cache from CacheClient parameters.
lookup(prompt: str, llm_string: str) → Optional[Sequence[Generation]][source]¶
Lookup llm generations in cache by prompt and associated model and settings.
Parameters
prompt (str) – The prompt run through the language model.
llm_string (str) – The language model version and settings.
Raises
SdkException – Momento service or network error
Returns
A list of language model generations.
Return type
Optional[RETURN_VAL_TYPE]
update(prompt: str, llm_string: str, return_val: Sequence[Generation]) → None[source]¶
Store llm generations in cache.
Parameters
langchain_community.cache.AstraDBCache¶
class langchain_community.cache.AstraDBCache(*, collection_name: str = 'langchain_astradb_cache', token: Optional[str] = None, api_endpoint: Optional[str] = None, astra_db_client: Optional[Any] = None, namespace: Optional[str] = None)[source]¶
Cache that uses Astra DB as a backend.
It uses a single collection as a kv store
The lookup keys, combined in the _id of the documents, are:
prompt, a string
llm_string, a deterministic str representation of the model parameters.
(needed to prevent same-prompt-different-model collisions)
Create an AstraDB cache using a collection for storage.
Args (only keyword-arguments accepted):collection_name (str): name of the Astra DB collection to create/use.
token (Optional[str]): API token for Astra DB usage.
api_endpoint (Optional[str]): full URL to the API endpoint,
such as “https://<DB-ID>-us-east1.apps.astra.datastax.com”.
astra_db_client (Optional[Any]): alternative to token+api_endpoint,you can pass an already-created ‘astrapy.db.AstraDB’ instance.
namespace (Optional[str]): namespace (aka keyspace) where thecollection is created. Defaults to the database’s “default namespace”.
Methods
__init__(*[, collection_name, token, ...])
Create an AstraDB cache using a collection for storage.
clear(**kwargs)
Clear cache.
delete(prompt, llm_string)
Evict from cache if there's an entry.
delete_through_llm(prompt, llm[, stop])
A wrapper around delete with the LLM being passed.
lookup(prompt, llm_string)
Look up based on prompt and llm_string.
lookup(prompt, llm_string)
Look up based on prompt and llm_string.
update(prompt, llm_string, return_val)
Update cache based on prompt and llm_string.
__init__(*, collection_name: str = 'langchain_astradb_cache', token: Optional[str] = None, api_endpoint: Optional[str] = None, astra_db_client: Optional[Any] = None, namespace: Optional[str] = None)[source]¶
Create an AstraDB cache using a collection for storage.
Args (only keyword-arguments accepted):collection_name (str): name of the Astra DB collection to create/use.
token (Optional[str]): API token for Astra DB usage.
api_endpoint (Optional[str]): full URL to the API endpoint,
such as “https://<DB-ID>-us-east1.apps.astra.datastax.com”.
astra_db_client (Optional[Any]): alternative to token+api_endpoint,you can pass an already-created ‘astrapy.db.AstraDB’ instance.
namespace (Optional[str]): namespace (aka keyspace) where thecollection is created. Defaults to the database’s “default namespace”.
clear(**kwargs: Any) → None[source]¶
Clear cache. This is for all LLMs at once.
delete(prompt: str, llm_string: str) → None[source]¶
Evict from cache if there’s an entry.
delete_through_llm(prompt: str, llm: LLM, stop: Optional[List[str]] = None) → None[source]¶
A wrapper around delete with the LLM being passed.
In case the llm(prompt) calls have a stop param, you should pass it here
lookup(prompt: str, llm_string: str) → Optional[Sequence[Generation]][source]¶
Look up based on prompt and llm_string.
langchain_community.cache.InMemoryCache¶
class langchain_community.cache.InMemoryCache[source]¶
Cache that stores things in memory.
Initialize with empty cache.
Methods
__init__()
Initialize with empty cache.
clear(**kwargs)
Clear cache.
lookup(prompt, llm_string)
Look up based on prompt and llm_string.
update(prompt, llm_string, return_val)
Update cache based on prompt and llm_string.
__init__() → None[source]¶
Initialize with empty cache.
clear(**kwargs: Any) → None[source]¶
Clear cache.
lookup(prompt: str, llm_string: str) → Optional[Sequence[Generation]][source]¶
Look up based on prompt and llm_string.
update(prompt: str, llm_string: str, return_val: Sequence[Generation]) → None[source]¶
Update cache based on prompt and llm_string.
Examples using InMemoryCache¶
LLM Caching integrations
langchain_community.cache.CassandraCache¶
class langchain_community.cache.CassandraCache(session: Optional[CassandraSession] = None, keyspace: Optional[str] = None, table_name: str = 'langchain_llm_cache', ttl_seconds: Optional[int] = None, skip_provisioning: bool = False)[source]¶
Cache that uses Cassandra / Astra DB as a backend.
It uses a single Cassandra table.
The lookup keys (which get to form the primary key) are:
prompt, a string
llm_string, a deterministic str representation of the model parameters.
(needed to prevent collisions same-prompt-different-model collisions)
Initialize with a ready session and a keyspace name.
:param session: an open Cassandra session
:type session: cassandra.cluster.Session
:param keyspace: the keyspace to use for storing the cache
:type keyspace: str
:param table_name: name of the Cassandra table to use as cache
:type table_name: str
:param ttl_seconds: time-to-live for cache entries
(default: None, i.e. forever)
Methods
__init__([session, keyspace, table_name, ...])
Initialize with a ready session and a keyspace name. :param session: an open Cassandra session :type session: cassandra.cluster.Session :param keyspace: the keyspace to use for storing the cache :type keyspace: str :param table_name: name of the Cassandra table to use as cache :type table_name: str :param ttl_seconds: time-to-live for cache entries                     (default: None, i.e. forever) :type ttl_seconds: optional int.
clear(**kwargs)
Clear cache.
delete(prompt, llm_string)
Evict from cache if there's an entry.
delete_through_llm(prompt, llm[, stop])
A wrapper around delete with the LLM being passed.
A wrapper around delete with the LLM being passed.
lookup(prompt, llm_string)
Look up based on prompt and llm_string.
update(prompt, llm_string, return_val)
Update cache based on prompt and llm_string.
__init__(session: Optional[CassandraSession] = None, keyspace: Optional[str] = None, table_name: str = 'langchain_llm_cache', ttl_seconds: Optional[int] = None, skip_provisioning: bool = False)[source]¶
Initialize with a ready session and a keyspace name.
:param session: an open Cassandra session
:type session: cassandra.cluster.Session
:param keyspace: the keyspace to use for storing the cache
:type keyspace: str
:param table_name: name of the Cassandra table to use as cache
:type table_name: str
:param ttl_seconds: time-to-live for cache entries
(default: None, i.e. forever)
clear(**kwargs: Any) → None[source]¶
Clear cache. This is for all LLMs at once.
delete(prompt: str, llm_string: str) → None[source]¶
Evict from cache if there’s an entry.
delete_through_llm(prompt: str, llm: LLM, stop: Optional[List[str]] = None) → None[source]¶
A wrapper around delete with the LLM being passed.
In case the llm(prompt) calls have a stop param, you should pass it here
lookup(prompt: str, llm_string: str) → Optional[Sequence[Generation]][source]¶
Look up based on prompt and llm_string.
update(prompt: str, llm_string: str, return_val: Sequence[Generation]) → None[source]¶
Update cache based on prompt and llm_string.
langchain_community.cache.RedisCache¶
class langchain_community.cache.RedisCache(redis_: Any, *, ttl: Optional[int] = None)[source]¶
Cache that uses Redis as a backend.
Initialize an instance of RedisCache.
This method initializes an object with Redis caching capabilities.
It takes a redis_ parameter, which should be an instance of a Redis
client class, allowing the object to interact with a Redis
server for caching purposes.
Parameters
redis (Any) – An instance of a Redis client class
(e.g., redis.Redis) used for caching.
This allows the object to communicate with a
Redis server for caching operations.
ttl (int, optional) – Time-to-live (TTL) for cached items in seconds.
If provided, it sets the time duration for how long cached
items will remain valid. If not provided, cached items will not
have an automatic expiration.
Methods
__init__(redis_, *[, ttl])
Initialize an instance of RedisCache.
clear(**kwargs)
Clear cache.
lookup(prompt, llm_string)
Look up based on prompt and llm_string.
update(prompt, llm_string, return_val)
Update cache based on prompt and llm_string.
__init__(redis_: Any, *, ttl: Optional[int] = None)[source]¶
Initialize an instance of RedisCache.
This method initializes an object with Redis caching capabilities.
It takes a redis_ parameter, which should be an instance of a Redis
client class, allowing the object to interact with a Redis
server for caching purposes.
Parameters
redis (Any) – An instance of a Redis client class
(e.g., redis.Redis) used for caching.
This allows the object to communicate with a
Redis server for caching operations.
ttl (int, optional) – Time-to-live (TTL) for cached items in seconds.
If provided, it sets the time duration for how long cached
items will remain valid. If not provided, cached items will not
have an automatic expiration.
clear(**kwargs: Any) → None[source]¶
Clear cache. If asynchronous is True, flush asynchronously.
lookup(prompt: str, llm_string: str) → Optional[Sequence[Generation]][source]¶
Look up based on prompt and llm_string.
update(prompt: str, llm_string: str, return_val: Sequence[Generation]) → None[source]¶
Update cache based on prompt and llm_string.
Examples using RedisCache¶
Redis
LLM Caching integrations
langchain_core.stores.BaseStore¶
class langchain_core.stores.BaseStore[source]¶
Abstract interface for a key-value store.
Methods
__init__()
mdelete(keys)
Delete the given keys and their associated values.
mget(keys)
Get the values associated with the given keys.
mset(key_value_pairs)
Set the values for the given keys.
yield_keys(*[, prefix])
Get an iterator over keys that match the given prefix.
__init__()¶
abstract mdelete(keys: Sequence[K]) → None[source]¶
Delete the given keys and their associated values.
Parameters
keys (Sequence[K]) – A sequence of keys to delete.
abstract mget(keys: Sequence[K]) → List[Optional[V]][source]¶
Get the values associated with the given keys.
Parameters
keys (Sequence[K]) – A sequence of keys.
Returns
A sequence of optional values associated with the keys.
If a key is not found, the corresponding value will be None.
abstract mset(key_value_pairs: Sequence[Tuple[K, V]]) → None[source]¶
Set the values for the given keys.
Parameters
key_value_pairs (Sequence[Tuple[K, V]]) – A sequence of key-value pairs.
abstract yield_keys(*, prefix: Optional[str] = None) → Union[Iterator[K], Iterator[str]][source]¶
Get an iterator over keys that match the given prefix.
Parameters
prefix (str) – The prefix to match.
Returns
An iterator over keys that match the given prefix.
This method is allowed to return an iterator over either K or str
depending on what makes more sense for the given store.
Return type
Iterator[K | str]
langchain_community.chat_loaders.telegram.TelegramChatLoader¶
class langchain_community.chat_loaders.telegram.TelegramChatLoader(path: Union[str, Path])[source]¶
Load telegram conversations to LangChain chat messages.
To export, use the Telegram Desktop app from
https://desktop.telegram.org/, select a conversation, click the three dots
in the top right corner, and select “Export chat history”. Then select
“Machine-readable JSON” (preferred) to export. Note: the ‘lite’ versions of
the desktop app (like “Telegram for MacOS”) do not support exporting chat
history.
Initialize the TelegramChatLoader.
Parameters
path (Union[str, Path]) – Path to the exported Telegram chat zip,
directory, json, or HTML file.
Methods
__init__(path)
Initialize the TelegramChatLoader.
lazy_load()
Lazy load the messages from the chat file and yield them in as chat sessions.
load()
Eagerly load the chat sessions into memory.
__init__(path: Union[str, Path])[source]¶
Initialize the TelegramChatLoader.
Parameters
path (Union[str, Path]) – Path to the exported Telegram chat zip,
directory, json, or HTML file.
lazy_load() → Iterator[ChatSession][source]¶
Lazy load the messages from the chat file and yield them
in as chat sessions.
Yields
ChatSession – The loaded chat session.
load() → List[ChatSession]¶
Eagerly load the chat sessions into memory.
Examples using TelegramChatLoader¶
Telegram
langchain_community.chat_loaders.utils.merge_chat_runs_in_session¶
langchain_community.chat_loaders.utils.merge_chat_runs_in_session(chat_session: ChatSession, delimiter: str = '\n\n') → ChatSession[source]¶
Merge chat runs together in a chat session.
A chat run is a sequence of messages from the same sender.
Parameters
chat_session – A chat session.
Returns
A chat session with merged chat runs.
langchain_community.chat_loaders.utils.merge_chat_runs¶
langchain_community.chat_loaders.utils.merge_chat_runs(chat_sessions: Iterable[ChatSession]) → Iterator[ChatSession][source]¶
Merge chat runs together.
A chat run is a sequence of messages from the same sender.
Parameters
chat_sessions – A list of chat sessions.
Returns
A list of chat sessions with merged chat runs.
Examples using merge_chat_runs¶
Facebook Messenger
Slack
WhatsApp
iMessage
Telegram
Discord
langchain_community.chat_loaders.facebook_messenger.SingleFileFacebookMessengerChatLoader¶
class langchain_community.chat_loaders.facebook_messenger.SingleFileFacebookMessengerChatLoader(path: Union[Path, str])[source]¶
Load Facebook Messenger chat data from a single file.
Parameters
path (Union[Path, str]) – The path to the chat file.
path¶
The path to the chat file.
Type
Path
Methods
__init__(path)
lazy_load()
Lazy loads the chat data from the file.
load()
Eagerly load the chat sessions into memory.
__init__(path: Union[Path, str]) → None[source]¶
lazy_load() → Iterator[ChatSession][source]¶
Lazy loads the chat data from the file.
Yields
ChatSession – A chat session containing the loaded messages.
load() → List[ChatSession]¶
Eagerly load the chat sessions into memory.
Examples using SingleFileFacebookMessengerChatLoader¶
Facebook Messenger
langchain_community.chat_loaders.imessage.IMessageChatLoader¶
class langchain_community.chat_loaders.imessage.IMessageChatLoader(path: Optional[Union[str, Path]] = None)[source]¶
Load chat sessions from the iMessage chat.db SQLite file.
It only works on macOS when you have iMessage enabled and have the chat.db file.
The chat.db file is likely located at ~/Library/Messages/chat.db. However, your
terminal may not have permission to access this file. To resolve this, you can
copy the file to a different location, change the permissions of the file, or
grant full disk access for your terminal emulator
in System Settings > Security and Privacy > Full Disk Access.
Initialize the IMessageChatLoader.
Parameters
path (str or Path, optional) – Path to the chat.db SQLite file.
Defaults to None, in which case the default path
~/Library/Messages/chat.db will be used.
Methods
__init__([path])
Initialize the IMessageChatLoader.
lazy_load()
Lazy load the chat sessions from the iMessage chat.db and yield them in the required format.
load()
Eagerly load the chat sessions into memory.
__init__(path: Optional[Union[str, Path]] = None)[source]¶
Initialize the IMessageChatLoader.
Parameters
path (str or Path, optional) – Path to the chat.db SQLite file.
Defaults to None, in which case the default path
~/Library/Messages/chat.db will be used.
lazy_load() → Iterator[ChatSession][source]¶
Lazy load the chat sessions from the iMessage chat.db
and yield them in the required format.
Yields
ChatSession – Loaded chat session.
load() → List[ChatSession]¶
Eagerly load the chat sessions into memory.
Examples using IMessageChatLoader¶
iMessage
langchain_community.chat_loaders.facebook_messenger.FolderFacebookMessengerChatLoader¶
class langchain_community.chat_loaders.facebook_messenger.FolderFacebookMessengerChatLoader(path: Union[str, Path])[source]¶
Load Facebook Messenger chat data from a folder.
Parameters
path (Union[str, Path]) – The path to the directory
containing the chat files.
path¶
The path to the directory containing the chat files.
Type
Path
Methods
__init__(path)
lazy_load()
Lazy loads the chat data from the folder.
load()
Eagerly load the chat sessions into memory.
__init__(path: Union[str, Path]) → None[source]¶
lazy_load() → Iterator[ChatSession][source]¶
Lazy loads the chat data from the folder.
Yields
ChatSession – A chat session containing the loaded messages.
load() → List[ChatSession]¶
Eagerly load the chat sessions into memory.
Examples using FolderFacebookMessengerChatLoader¶
Facebook Messenger
Chat loaders
langchain_community.chat_loaders.whatsapp.WhatsAppChatLoader¶
class langchain_community.chat_loaders.whatsapp.WhatsAppChatLoader(path: str)[source]¶
Load WhatsApp conversations from a dump zip file or directory.
Initialize the WhatsAppChatLoader.
Parameters
path (str) – Path to the exported WhatsApp chat
zip directory, folder, or file.
To generate the dump, open the chat, click the three dots in the top
right corner, and select “More”. Then select “Export chat” and
choose “Without media”.
Methods
__init__(path)
Initialize the WhatsAppChatLoader.
lazy_load()
Lazy load the messages from the chat file and yield them as chat sessions.
load()
Eagerly load the chat sessions into memory.
__init__(path: str)[source]¶
Initialize the WhatsAppChatLoader.
Parameters
path (str) – Path to the exported WhatsApp chat
zip directory, folder, or file.
To generate the dump, open the chat, click the three dots in the top
right corner, and select “More”. Then select “Export chat” and
choose “Without media”.
lazy_load() → Iterator[ChatSession][source]¶
Lazy load the messages from the chat file and yield
them as chat sessions.
Yields
Iterator[ChatSession] – The loaded chat sessions.
load() → List[ChatSession]¶
Eagerly load the chat sessions into memory.
Examples using WhatsAppChatLoader¶
WhatsApp
WhatsApp Chat
langchain_community.chat_loaders.utils.map_ai_messages¶
langchain_community.chat_loaders.utils.map_ai_messages(chat_sessions: Iterable[ChatSession], sender: str) → Iterator[ChatSession][source]¶
Convert messages from the specified ‘sender’ to AI messages.
This is useful for fine-tuning the AI to adapt to your voice.
Examples using map_ai_messages¶
Facebook Messenger
GMail
Slack
WhatsApp
iMessage
Telegram
Discord
langchain_community.chat_loaders.gmail.GMailLoader¶
class langchain_community.chat_loaders.gmail.GMailLoader(creds: Any, n: int = 100, raise_error: bool = False)[source]¶
Load data from GMail.
There are many ways you could want to load data from GMail.
This loader is currently fairly opinionated in how to do so.
The way it does it is it first looks for all messages that you have sent.
It then looks for messages where you are responding to a previous email.
It then fetches that previous email, and creates a training example
of that email, followed by your email.
Note that there are clear limitations here. For example,
all examples created are only looking at the previous email for context.
To use:
Set up a Google Developer Account:Go to the Google Developer Console, create a project,
and enable the Gmail API for that project.
This will give you a credentials.json file that you’ll need later.
Methods
__init__(creds[, n, raise_error])
lazy_load()
Lazy load the chat sessions.
load()
Eagerly load the chat sessions into memory.
__init__(creds: Any, n: int = 100, raise_error: bool = False) → None[source]¶
lazy_load() → Iterator[ChatSession][source]¶
Lazy load the chat sessions.
load() → List[ChatSession]¶
Eagerly load the chat sessions into memory.
Examples using GMailLoader¶
GMail
langchain_community.chat_loaders.langsmith.LangSmithRunChatLoader¶
class langchain_community.chat_loaders.langsmith.LangSmithRunChatLoader(runs: Iterable[Union[str, Run]], client: Optional['Client'] = None)[source]¶
Load chat sessions from a list of LangSmith “llm” runs.
runs¶
The list of LLM run IDs or run objects.
Type
Iterable[Union[str, Run]]
client¶
Instance of LangSmith client for fetching data.
Type
Client
Initialize a new LangSmithRunChatLoader instance.
Parameters
runs – List of LLM run IDs or run objects.
client – An instance of LangSmith client, if not provided,
a new client instance will be created.
Methods
__init__(runs[, client])
Initialize a new LangSmithRunChatLoader instance.
lazy_load()
Lazy load the chat sessions from the iterable of run IDs.
load()
Eagerly load the chat sessions into memory.
__init__(runs: Iterable[Union[str, Run]], client: Optional['Client'] = None)[source]¶
Initialize a new LangSmithRunChatLoader instance.
Parameters
runs – List of LLM run IDs or run objects.
client – An instance of LangSmith client, if not provided,
a new client instance will be created.
lazy_load() → Iterator[ChatSession][source]¶
Lazy load the chat sessions from the iterable of run IDs.
This method fetches the runs and converts them to chat sessions on-the-fly,
yielding one session at a time.
Returns
Iterator of chat sessions containing messages.
load() → List[ChatSession]¶
Eagerly load the chat sessions into memory.
langchain_community.chat_loaders.base.BaseChatLoader¶
class langchain_community.chat_loaders.base.BaseChatLoader[source]¶
Base class for chat loaders.
Methods
__init__()
lazy_load()
Lazy load the chat sessions.
load()
Eagerly load the chat sessions into memory.
__init__()¶
abstract lazy_load() → Iterator[ChatSession][source]¶
Lazy load the chat sessions.
load() → List[ChatSession][source]¶
Eagerly load the chat sessions into memory.
langchain_community.chat_loaders.slack.SlackChatLoader¶
class langchain_community.chat_loaders.slack.SlackChatLoader(path: Union[str, Path])[source]¶
Load Slack conversations from a dump zip file.
Initialize the chat loader with the path to the exported Slack dump zip file.
Parameters
path – Path to the exported Slack dump zip file.
Methods
__init__(path)
Initialize the chat loader with the path to the exported Slack dump zip file.
lazy_load()
Lazy load the chat sessions from the Slack dump file and yield them in the required format.
load()
Eagerly load the chat sessions into memory.
__init__(path: Union[str, Path])[source]¶
Initialize the chat loader with the path to the exported Slack dump zip file.
Parameters
path – Path to the exported Slack dump zip file.
lazy_load() → Iterator[ChatSession][source]¶
Lazy load the chat sessions from the Slack dump file and yield them
in the required format.
Returns
Iterator of chat sessions containing messages.
load() → List[ChatSession]¶
Eagerly load the chat sessions into memory.
Examples using SlackChatLoader¶
Slack