o .if[@s8dZddlmZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z ddl mZddlmZmZmZmZmZmZmZmZmZmZddlmZmZmZmZmZdd l m!Z!dd l"m#Z#dd l$m%Z%zdd l$m&Z&Wne'ydd l(m&Z&Ynwdd l)m*Z*m+Z+ddl,m-Z-ddl.m/Z/m0Z0ddl1m2Z2ddl3m4Z4ddl5m6Z6m7Z7ddl8m9Z9ddl:m;Z;ddle?e@ZAerddlBZBddlCmDZDdd lEm%ZFd\ddZGd]ddZHd^d!d"ZId]d#d$ZJd_d'd(ZKGd)d*d*e+ZLe&ZMGd+d,d,eMZNGd-d.d.e+ZOGd/d0d0eOZPGd1d2d2e+ZQGd3d4d4e+e ZRGd5d6d6eRZSGd7d8d8eRZTGd9d:d:e+ZUGd;d<d Cache # Examples: InMemoryCache, RedisCache, GPTCache ) annotationsN)ABC) timedelta) lru_cache) TYPE_CHECKINGAnyCallableDictListOptionalTupleTypeUnioncast)ColumnIntegerString create_engineselect)Row)Engine)Session)declarative_base)RETURN_VAL_TYPE BaseCache) Embeddings)LLM get_promptsdumpsloads)ChatGeneration Generation) get_from_env)AstraDBEnvironmentRedis)AstraDB_inputstrreturncCt|S)z%Use a deterministic hashing approach.hashlibmd5encode hexdigest)r)r2R/var/www/html/corbot_env/lib/python3.10/site-packages/langchain_community/cache.py_hashKr4 generationsrcCtdd|DS)aDump generations to json. Args: generations (RETURN_VAL_TYPE): A list of language model generations. Returns: str: Json representing a list of generations. Warning: would not work well with arbitrary subclasses of `Generation` cSg|]}|qSr2dict.0 generationr2r2r3 [z-_dump_generations_to_json..jsonrr6r2r2r3_dump_generations_to_jsonPs rCgenerations_jsoncCs:z t|}dd|DWStjytd|w)a`Load generations from json. Args: generations_json (str): A string of json representing a list of generations. Raises: ValueError: Could not decode json string to list of generations. Returns: RETURN_VAL_TYPE: A list of generations. Warning: would not work well with arbitrary subclasses of `Generation` cSg|] }tdi|qSr2r#r<generation_dictr2r2r3r>nz/_load_generations_from_json..z.Could not decode json to list of generations: )rAr!JSONDecodeError ValueError)rDresultsr2r2r3_load_generations_from_json^s rNcCr7)a Serialization for generic RETURN_VAL_TYPE, i.e. sequence of `Generation` Args: generations (RETURN_VAL_TYPE): A list of language model generations. Returns: str: a single string representing a list of generations. This function (+ its counterpart `_loads_generations`) rely on the dumps/loads pair with Reviver, so are able to deal with all subclasses of Generation. Each item in the list can be `dumps`ed to a string, then we make the whole list of strings into a json-dumped. cSg|]}t|qSr2r)r<_itemr2r2r3r>r?z&_dumps_generations..r@rBr2r2r3_dumps_generationsusrQgenerations_strUnion[RETURN_VAL_TYPE, None]c Csz ddt|D}|WStjtfyYnwzt|}dd|D}td|d|WStjtfyHtd|dYdSw)a Deserialization of a string into a generic RETURN_VAL_TYPE (i.e. a sequence of `Generation`). See `_dumps_generations`, the inverse of this function. Args: generations_str (str): A string representing a list of generations. Compatible with the legacy cache-blob format Does not raise exceptions for malformed entries, just logs a warning and returns none: the caller should be prepared for such a cache miss. Returns: RETURN_VAL_TYPE: A list of generations. cSrOr2r )r< _item_strr2r2r3r>r?z&_loads_generations..cSrErFrGrHr2r2r3r>rJz.Legacy 'Generation' cached blob encountered: ''z/Malformed/unparsable cached blob encountered: 'N)rAr!rK TypeErrorloggerwarning)rRr6 gen_dictsr2r2r3_loads_generationss&   rZc@sVeZdZdZdddZdd d ZdddZdddZdddZdddZ dddZ dS) InMemoryCachez#Cache that stores things in memory.r+NonecC i|_dS)zInitialize with empty cache.N_cacheselfr2r2r3__init__ zInMemoryCache.__init__promptr* llm_stringOptional[RETURN_VAL_TYPE]cCs|j||fdS)'Look up based on prompt and llm_string.N)r_getrardrer2r2r3lookupr5zInMemoryCache.lookup return_valrcCs||j||f<dS,Update cache based on prompt and llm_string.Nr^rardrerkr2r2r3updater5zInMemoryCache.updatekwargsrcKr] Clear cache.Nr^rarpr2r2r3clearrczInMemoryCache.clearcs|||Srg)rjrir2r2r3alookup zInMemoryCache.alookupcs||||dSrl)rornr2r2r3aupdateszInMemoryCache.aupdatecs|dSrq)rtrsr2r2r3aclearrwzInMemoryCache.aclearN)r+r\rdr*rer*r+rfrdr*rer*rkrr+r\rprr+r\) __name__ __module__ __qualname____doc__rbrjrortrvrxryr2r2r2r3r[s      r[c@s@eZdZdZdZeeddZeeddZee ddZ eeZ dS) FullLLMCache2SQLite table for full LLM Cache (all generations).full_llm_cacheT primary_keyN) r}r~rr __tablename__rrrdllmridxresponser2r2r2r3rs    rc@s<eZdZdZefdddZdd dZdddZdddZdS)SQLAlchemyCache'Cache that uses SQAlchemy as a backend.enginer cache_schemaType[FullLLMCache]cC ||_||_|jj|jdSz"Initialize by creating all tables.Nrrmetadata create_allrarrr2r2r3rbszSQLAlchemyCache.__init__rdr*rer+rfc Cst|jj|jj|k|jj|k|jj}t|j >}| | }|rTzdd|DWWdSt ySt ddd|DYWdSwWddS1s_wYdS)rgcSg|]}t|dqSrr r<rowr2r2r3r>z*SQLAlchemyCache.lookup..NRetrieving a cache value that could not be deserialized properly. This is likely due to the cache being in an older format. Please recreate your cache to avoid this error.cSsg|] }t|ddqS)rtextrGrr2r2r3r>rJ)rrrwhererdrorder_byrrrexecutefetchall ExceptionrWrX)rardrestmtsessionrowsr2r2r3rjs.     zSQLAlchemyCache.lookuprkrr\c sfddt|D}tj/}||D]}||qWdn1s,wYWddSWddS1sDwYdS)&Update based on prompt and llm_string.cs&g|]\}}jt||dqS))rdrrr)rrr<igenrerdrar2r3r>sz*SQLAlchemyCache.update..N) enumeraterrbeginmergerardrerkitemsritemr2rr3ros PzSQLAlchemyCache.updaterprcKsHt|j}||j|WddS1swYdSrq)rrqueryrdeletecommitrarprr2r2r3rt s  "zSQLAlchemyCache.clearN)rrrrrzr{r|) r}r~rrrrbrjrortr2r2r2r3rs    rcs$eZdZdZddfdd ZZS) SQLiteCachez$Cache that uses SQLite as a backend. .langchain.db database_pathr*cstd|}t|dS)z1Initialize by creating the engine and all tables.z sqlite:///N)rsuperrb)rarr __class__r2r3rbszSQLiteCache.__init__)r)rr*)r}r~rrrb __classcell__r2r2rr3rsrc@sHeZdZdZddddd ZdddZdddZdddZdddZdS) UpstashRedisCachez+Cache that uses Upstash Redis as a backend.Nttlredis_rr Optional[int]cCJzddlm}Wn tytdwt||std||_||_dS)ag Initialize an instance of UpstashRedisCache. This method initializes an object with Upstash Redis caching capabilities. It takes a `redis_` parameter, which should be an instance of an Upstash Redis client class, allowing the object to interact with Upstash Redis server for caching purposes. Parameters: redis_: An instance of Upstash Redis client class (e.g., Redis) used for caching. This allows the object to communicate with Redis server for caching operations on. 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. rr&zbCould not import upstash_redis python package. Please install it with `pip install upstash_redis`.z$Please pass in Upstash Redis object.N) upstash_redisr' ImportErrorrL isinstanceredisrrarrr'r2r2r3rb   zUpstashRedisCache.__init__rdr*rer+cC t||Sz&Compute key from prompt and llm_stringr4rir2r2r3_key=s zUpstashRedisCache._keyrfcCsJg}|j|||}|r|D] \}}|t|dq|r#|SdS)rgrN)rhgetallrrappendr#)rardrer6rM_rr2r2r3rjAs  zUpstashRedisCache.lookuprkrr\cCs|D]}t|tstdt|t|trtddSq|||}ddt|D}|j j ||d|j durF|j ||j dSdS)rmzBUpstashRedisCache supports caching of normal LLM generations, got zcNOTE: Generation has not been cached. UpstashRedisCache does not support caching ChatModel outputs.NcSsi|] \}}t||jqSr2)r*rr<rr=r2r2r3 \sz,UpstashRedisCache.update..)keyvalues) rr#rLtyper"warningswarnrrrhsetrexpire)rardrerkrrmappingr2r2r3roKs*    zUpstashRedisCache.updaterpcKs,|dd}|r d}nd}|jj|ddS)zt Clear cache. If `asynchronous` is True, flush asynchronously. This flushes the *whole* db. asynchronousFASYNCSYNC) flush_typeNrhrflushdbrarprr2r2r3rtds zUpstashRedisCache.clearrrrrrdr*rer*r+r*rzr{r|) r}r~rrrbrrjrortr2r2r2r3rs   rc@sHeZdZedddZedd d ZedddZe ddddZdS)_RedisCacheBaserdr*rer+cCs t||Srrrdrer2r2r3rrs z_RedisCacheBase._keyrkrr\cCs*|D]}t|tstdt|qdS)Nz@RedisCache only supports caching of normal LLM generations, got )rr#rLr)rkrr2r2r3_ensure_generation_typews z'_RedisCacheBase._ensure_generation_typerMdict[str | bytes, str | bytes]Optional[List[Generation]]c Csdg}|r,|D]#\}}z |t|Wqty+td|t|dYqw|r0|SdS)Nrr)rrr!rrWrXr#)rMr6rrr2r2r3_get_generationss  z _RedisCacheBase._get_generationsNrpiperrrcCs8|j|ddt|Dd|dur|||dSdS)NcSsi|] \}}t|t|qSr2)r*rrr2r2r3rszB_RedisCacheBase._configure_pipeline_for_update..)r)rrr)rrrkrr2r2r3_configure_pipeline_for_updatesz._RedisCacheBase._configure_pipeline_for_updater)rkrr+r\)rMrr+rN) rr*rrrkrrrr+r\)r}r~r staticmethodrrrrr2r2r2r3rqs   rc@s>eZdZdZddddd ZdddZdddZdddZdS) RedisCachezX Cache that uses Redis as a backend. Allows to use a sync `redis.Redis` client. NrrrrrcCsJzddlm}Wn tytdwt||std||_||_dS)a` 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 (`redis.Redis`), allowing the object to interact with a Redis server for caching purposes. Parameters: redis_ (Any): An instance of a Redis client class (`redis.Redis`) to be 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. rr&zTCould not import `redis` python package. Please install it with `pip install redis`.z)Please pass a valid `redis.Redis` client.N)rr'rrLrrrr2r2r3rbrzRedisCache.__init__rdr*rer+rfcCs|j|||}||SrurrrrrardrerMr2r2r3rjs zRedisCache.lookuprkrr\cCs`|||||}|j}|||||j|WddS1s)wYdSrlrrrpipelinerrrrardrerkrrr2r2r3ros    "zRedisCache.updaterpcKs&|dd}|jjdd|i|dS)=Clear cache. If `asynchronous` is True, flush asynchronously.rFNr2rrr2r2r3rts zRedisCache.clearrrzr{r|)r}r~rrrbrjrortr2r2r2r3rs    rc@s\eZdZdZddddd Zd ddZd ddZd!ddZd!ddZd"ddZ d"ddZ dS)#AsyncRedisCachezf Cache that uses Redis as a backend. Allows to use an async `redis.asyncio.Redis` client. NrrrrrcCr)au Initialize an instance of AsyncRedisCache. This method initializes an object with Redis caching capabilities. It takes a `redis_` parameter, which should be an instance of a Redis client class (`redis.asyncio.Redis`), allowing the object to interact with a Redis server for caching purposes. Parameters: redis_ (Any): An instance of a Redis client class (`redis.asyncio.Redis`) to be 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. rr&z\Could not import `redis.asyncio` python package. Please install it with `pip install redis`.z1Please pass a valid `redis.asyncio.Redis` client.N) redis.asyncior'rrLrrrrr2r2r3rbrzAsyncRedisCache.__init__rdr*rer+rfcCtd)rgzjThis async Redis cache does not implement `lookup()` method. Consider using the async `alookup()` version.NotImplementedErrorrir2r2r3rjzAsyncRedisCache.lookupcs&|j|||IdH}||S)z6Look up based on prompt and llm_string. Async version.Nrrr2r2r3rvs zAsyncRedisCache.alookuprkrr\cCr)rmzjThis async Redis cache does not implement `update()` method. Consider using the async `aupdate()` version.rrnr2r2r3ro rzAsyncRedisCache.updatec s||||||}|j4IdH}|||||j|IdHWdIdHdS1IdHs7wYdS)z;Update cache based on prompt and llm_string. Async version.Nrrr2r2r3rxs  .zAsyncRedisCache.aupdaterpcKr)rzhThis async Redis cache does not implement `clear()` method. Consider using the async `aclear()` version.rrsr2r2r3rtrzAsyncRedisCache.clearcs.|dd}|jjdd|i|IdHdS)zf Clear cache. If `asynchronous` is True, flush asynchronously. Async version. rFNr2rrr2r2r3ry&s  zAsyncRedisCache.aclearrrzr{r|) r}r~rrrbrjrvrorxrtryr2r2r2r3rs     rc@sneZdZdZdddigddiddigdZ d"d#ddZd$ddZd%ddZd&ddZd'ddZ d(dd Z d!S))RedisSemanticCachez0Cache that uses Redis as a vector-store backend.rdnamerkre) content_keyrextra皙? redis_urlr* embeddingrscore_thresholdfloatcCsi|_||_||_||_dS)aInitialize by passing in the `init` GPTCache func Args: redis_url (str): URL to connect to Redis. embedding (Embedding): Embedding provider for semantic encoding and search. score_threshold (float, 0.2): Example: .. code-block:: python from langchain_community.globals import set_llm_cache from langchain_community.cache import RedisSemanticCache from langchain_community.embeddings import OpenAIEmbeddings set_llm_cache(RedisSemanticCache( redis_url="redis://localhost:6379", embedding=OpenAIEmbeddings() )) N) _cache_dictrrr)rarrrr2r2r3rb<s zRedisSemanticCache.__init__r+cCst|}d|S)Nzcache:r)rare hashed_indexr2r2r3 _index_nameZs zRedisSemanticCache._index_nameRedisVectorstorec Cs||}||jvr|j|Sztj|j||jtt|jd|j|<Wn+t yNt|j||jtt|jd}|jj dd}|j t |d||j|<Ynw|j|S)N)r index_namerschema)rrr index_schematestr)dim) rrrfrom_existing_indexrrrr DEFAULT_SCHEMArL embed_query_create_index_if_not_existlen)rarerr _embeddingr2r2r3_get_llm_cache^s,       z!RedisSemanticCache._get_llm_cacherprr\cKs@||d}||jvr|j|j|d|jd|j|=dSdS)z,Clear semantic cache for a given llm_string.reT)rdelete_documentsrN)rr drop_indexr)rarprr2r2r3rtzs   zRedisSemanticCache.clearrfc Cs||}g}|j|d|jd}|r;|D]&}z |t|jdWqty:td|t |jdYqw|r?|SdS)rg)rkdistance_thresholdrkrN) rsimilarity_searchrextendr!rrrWrXrN)rardre llm_cacher6rMdocumentr2r2r3rjs(    zRedisSemanticCache.lookuprcCs`|D]}t|tstdt|q||}||tdd|Dd}|j|g|gddS)rmzHRedisSemanticCache only supports caching of normal LLM generations, got cSsg|]}|qSr2r2)r<gr2r2r3r>sz-RedisSemanticCache.update..)rerdrk)texts metadatasN)rr#rLrrr add_texts)rardrerkrrrr2r2r3ros  zRedisSemanticCache.updateN)r)rr*rrrr)rer*r+r*)rer*r+rr|rzr{) r}r~rrr rbrrrtrjror2r2r2r3r/s    rc@sPeZdZdZ ddddZdd d Zdd dZdddZdddZd ddZ dS)!GPTCachez&Cache that uses GPTCache as a backend.N init_func>Union[Callable[[Any, str], None], Callable[[Any], None], None]cCs4zddl}Wn tytdw||_i|_dS)a Initialize by passing in init function (default: `None`). Args: init_func (Optional[Callable[[Any], None]]): init `GPTCache` function (default: `None`) Example: .. code-block:: python # Initialize GPTCache with a custom init function import gptcache from gptcache.processor.pre import get_prompt from gptcache.manager.factory import get_data_manager from langchain_community.globals import set_llm_cache # Avoid multiple caches using the same file, causing different llm model caches to affect each other def init_gptcache(cache_obj: gptcache.Cache, llm str): cache_obj.init( pre_embedding_func=get_prompt, data_manager=manager_factory( manager="map", data_dir=f"map_cache_{llm}" ), ) set_llm_cache(GPTCache(init_gptcache)) rNzXCould not import gptcache python package. Please install it with `pip install gptcache`.)gptcacherinit_gptcache_func gptcache_dict)rarr!r2r2r3rbs$   zGPTCache.__init__rer*r+rcCsddlm}ddlm}ddlm}|}|jdur4t|j}t |j dkr.|||n||n |j |||dd||j |<|S) zNew gptcache objectrCache)get_data_manager) get_promptN) data_path)pre_embedding_func data_manager) r!r%gptcache.manager.factoryr&gptcache.processor.prer'r"inspect signaturer parametersinitr#)rarer%r&r' _gptcachesigr2r2r3 _new_gptcaches       zGPTCache._new_gptcachecCs |j|d}|s||}|S)zgGet a cache object. When the corresponding llm model cache does not exist, it will be created.N)r#rhr4)rarer2r2r2r3 _get_gptcaches zGPTCache._get_gptcacherdrfcCs>ddlm}||}|||d}|rddt|DSdS)zLook up the cache data. First, retrieve the corresponding cache object using the `llm_string` parameter, and then retrieve the data from the cache based on the `prompt`. r)rh cache_objcSrErFrGrHr2r2r3r>sz#GPTCache.lookup..N)gptcache.adapter.apirhr5rAr!)rardrerhr2resr2r2r3rjs   zGPTCache.lookuprkrr\cCsb|D]}t|tstdt|qddlm}||}tdd|D}||||ddS)zUpdate cache. First, retrieve the corresponding cache object using the `llm_string` parameter, and then store the `prompt` and `return_val` in the cache object. z>GPTCache only supports caching of normal LLM generations, got r)putcSr8r2r9r;r2r2r3r>"r?z#GPTCache.update..r6N) rr#rLrr8r:r5rAr)rardrerkrr:r2 handled_datar2r2r3ros   zGPTCache.updaterpcKs<ddlm}|jD] }t||}|q |jdS)rrrr$N)r!r%r#rrflushrt)rarpr%gptcache_instancer2r2r3rt&s   zGPTCache.clearr)rr )rer*r+rrzr{r|) r}r~rrrbr4r5rjrortr2r2r2r3rs 1  r cache_clientmomento.CacheClient cache_namer\cCsRddlm}||}t||jst||jrdSt||jr"|jtd|)zCreate cache if it doesn't exist. Raises: SdkException: Momento service or network error Exception: Unexpected response r) CreateCacheNz$Unexpected response cache creation: ) momento.responsesrA create_cacherSuccessCacheAlreadyExistsErrorinner_exceptionr)r>r@rAcreate_cache_responser2r2r3_ensure_cache_exists1s   rIrOptional[timedelta]cCs.|dur|tddkrtd|ddSdS)Nr)secondszttl must be positive but was .)rrLrr2r2r3 _validate_ttlEsrMc@sbeZdZdZdddd)d dZeddddd*ddZd+ddZd,d d!Zd-d%d&Z d.d'd(Z dS)/ MomentoCachez@Cache that uses Momento as a backend. See https://gomomento.com/NT)rensure_cache_existsr>r?r@r*rrJrOboolcCsfzddlm}Wn tytdwt||stdt||r(t||||_||_||_ dS)aUInstantiate 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/. Args: 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 r) CacheClientVCould not import momento python package. Please install it with `pip install momento`.z2cache_client must be a momento.CacheClient object.N) momentorQrrrVrMrIr>r@r)rar>r@rrOrQr2r2r3rbMs    zMomentoCache.__init__) configurationapi_key auth_tokenrrT&Optional[momento.config.Configuration]rU Optional[str]rVrprr+c Ksz ddlm}m}m} Wn tytdw|dur!|j}z |p(tdd}Wnty:|p7tdd}Ynw| |} ||| |d } || |fd |i|S) z,Construct cache from CacheClient parameters.r)rQConfigurationsCredentialProviderrRNrVMOMENTO_AUTH_TOKENrUMOMENTO_API_KEY) default_ttlr) rSrQrYrZrLaptopv1r$rL from_string) clsr@rrTrUrVrprQrYrZ credentialsr>r2r2r3from_client_paramsxs"     zMomentoCache.from_client_paramsrdrecCr)aCompute cache key from prompt and associated model and settings. Args: prompt (str): The prompt run through the language model. llm_string (str): The language model version and settings. Returns: str: The cache key. rrir2r2r3__keys zMomentoCache.__keyrfcCspddlm}g}|j|j|||}t||jr"|j}t |}nt||j r)n t||j r2|j |r6|SdS)aLookup llm generations in cache by prompt and associated model and settings. Args: 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: Optional[RETURN_VAL_TYPE]: A list of language model generations. r)CacheGetN) rBrer>rhr@_MomentoCache__keyrHit value_stringrNMissrFrG)rardrerer6 get_responsevaluer2r2r3rjs      zMomentoCache.lookuprkrr\c Cs|D]}t|tstdt|q|||}t|}|j|j|||j }ddl m }t||j r6dSt||j r?|jtd|)a|Store llm generations in cache. Args: prompt (str): The prompt run through the language model. llm_string (str): The language model string. return_val (RETURN_VAL_TYPE): A list of language model generations. Raises: SdkException: Momento service or network error Exception: Unexpected response z=Momento only supports caching of normal LLM generations, got r)CacheSetzUnexpected response: N)rr#rLrrfrCr>setr@rrBrlrDrFrGr) rardrerkrrrk set_responserlr2r2r3ros"     zMomentoCache.updatecKs@ddlm}|j|j}t||jrdSt||jr|jdS)zeClear the cache. Raises: SdkException: Momento service or network error r) CacheFlushN) rBror> flush_cacher@rrDrFrG)rarproflush_responser2r2r3rts   zMomentoCache.clear)r>r?r@r*rrJrOrP)r@r*rrrTrWrUrXrVrXrprr+rNrrzr{r|) r}r~rrrb classmethodrcrfrjrortr2r2r2r3rNJs+  rNlangchain_llm_cachec@s\eZdZdZddeedfd'ddZd(ddZd)ddZ d*d+dd Z d,d!d"Z d-d%d&Z dS).CassandraCachea] 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) NFrOptional[CassandraSession]keyspacerX table_namer* ttl_secondsrskip_provisioningrPc Cspzddlm}Wn ttfytdw||_||_||_||_||j|j|jddgddg|j|d|_ dS) a Initialize with a ready session and a keyspace name. Args: session (cassandra.cluster.Session): an open Cassandra session keyspace (str): the keyspace to use for storing the cache table_name (str): name of the Cassandra table to use as cache ttl_seconds (optional int): time-to-live for cache entries (default: None, i.e. forever) r)ElasticCassandraTableTCould not import cassio python package. Please install it with `pip install cassio`.rerdTEXT)rrvtablekeysprimary_key_typerxryN) cassio.tablerzrModuleNotFoundErrorrLrrvrwrxkv_cache)rarrvrwrxryrzr2r2r3rbs( zCassandraCache.__init__rdrer+rfcCs@|jjt|t|d}|durt|d}|dur|SdSdS)rgrerdN body_blob)rrhr4rZ)rardrerr6r2r2r3rj$s zCassandraCache.lookuprkrr\cCs&t|}|jjt|t||ddS)rm)rerdrN)rQrr:r4)rardrerkblobr2r2r3ro4s  zCassandraCache.updaterrstopOptional[List[str]]cC,ti|d|igd}|j||dSz A wrapper around `delete` with the LLM being passed. In case the llm(prompt) calls have a `stop` param, you should pass it here rrrerr:rrardrrrer2r2r3delete_through_llm=z!CassandraCache.delete_through_llmcCs|jjt|t|dS)%Evict from cache if there's an entry.r)rrr4rir2r2r3rJszCassandraCache.deleterprcK|jdSz*Clear cache. This is for all LLMs at once.N)rrtrsr2r2r3rtQzCassandraCache.clear) rrurvrXrwr*rxrryrPrzr{rrdr*rrrrr+r\rdr*rer*r+r\r|) r}r~rr"CASSANDRA_CACHE_DEFAULT_TABLE_NAME#CASSANDRA_CACHE_DEFAULT_TTL_SECONDSrbrjrorrrtr2r2r2r3rts  (  rtdotg333333?langchain_llm_semantic_cachec@speZdZdZeeeedfd3ddZd4ddZ d5ddZ d6d d!Z d7d#d$Z %d8d9d*d+Z d:d-d.Zd;d1d2Zd%S)<CassandraSemanticCachea Cache that uses Cassandra as a vector-store backend for semantic (i.e. similarity-based) lookup. It uses a single (vector) Cassandra table and stores, in principle, cached values from several LLMs, so the LLM's llm_string is part of the rows' primary keys. The similarity is based on one of several distance metrics (default: "dot"). If choosing another metric, the default threshold is to be re-tuned accordingly. FrrurvrXrrrwr*distance_metricrrrxrryrPc szddlm} Wn ttfytdw|_|_|_|_|_ |_ |_ t t ddfd d } | __| jjjd gjj d d hf|d_dS)a Initialize the cache with all relevant parameters. Args: session (cassandra.cluster.Session): an open Cassandra session keyspace (str): the keyspace to use for storing the cache embedding (Embedding): Embedding provider for semantic encoding and search. table_name (str): name of the Cassandra (vector) table to use as cache distance_metric (str, 'dot'): which measure to adopt for similarity searches score_threshold (optional float): numeric value to use as cutoff for the similarity searches ttl_seconds (optional int): time-to-live for cache entries (default: None, i.e. forever) The default score threshold is tuned to the default metric. Tune it carefully yourself if switching to another distance metric. r)MetadataVectorCassandraTabler{maxsizerr*r+ List[float]cjj|dSNrrr rr`r2r3_cache_embeddingrz9CassandraSemanticCache.__init__.._cache_embeddingr|allow_llm_string_hash)rrvr}rvector_dimensionrxmetadata_indexingryNrr*r+r)rrrrrLrrvrrwrrrxr-CASSANDRA_SEMANTIC_CACHE_EMBEDDING_CACHE_SIZE_get_embedding_get_embedding_dimensionembedding_dimensionr}) rarrvrrwrrrxryrrr2r`r3rbjs8  zCassandraSemanticCache.__init__r+intcCt|jddSNzThis is a sample sentence.rrrr`r2r2r3rz/CassandraSemanticCache._get_embedding_dimensionrdrerkrr\c CsP|j|d}t|}t|}||d}t|d|}|jj||||ddS)rmr)_promptr-)rvectorrow_idrN)rr4rQr}r:) rardrerkembedding_vectorllm_string_hashbodyrrr2r2r3ros  zCassandraSemanticCache.updaterfcC |||}|dur|dSdSrgNrlookup_with_idrardre hit_with_idr2r2r3rj zCassandraSemanticCache.lookup%Optional[Tuple[str, RETURN_VAL_TYPE]]cCsf|j|d}t|jj|dt|id|j|jd}|r1|d}t|d}|dur/|d|fSdSdS) zw Look up based on prompt and llm_string. If there are hits, return (document_id, cached_entry) rrr)rrnmetricmetric_thresholdrrNr)rlistr}metric_ann_searchr4rrrZ)rardreprompt_embeddinghitshitr6r2r2r3rs&    z%CassandraSemanticCache.lookup_with_idNrrrrcCrNrrrrr:rrr2r2r3lookup_with_id_through_llmz1CassandraSemanticCache.lookup_with_id_through_llm document_idcCs|jj|ddS) Given this is a "similarity search" cache, an invalidation pattern that makes sense is first a lookup to get an ID, and then deleting with that ID. This is for the second step. )rN)r}rrarr2r2r3delete_by_document_idsz,CassandraSemanticCache.delete_by_document_idrprcKrz!Clear the *whole* semantic cache.N)r}rtrsr2r2r3rtrzCassandraSemanticCache.clear)rrurvrXrrrwr*rr*rrrxrryrPr+rr{rzrdr*rer*r+rrrdr*rrrrr+rrr*r+r\r|)r}r~rr+CASSANDRA_SEMANTIC_CACHE_DEFAULT_TABLE_NAME0CASSANDRA_SEMANTIC_CACHE_DEFAULT_DISTANCE_METRIC0CASSANDRA_SEMANTIC_CACHE_DEFAULT_SCORE_THRESHOLD,CASSANDRA_SEMANTIC_CACHE_DEFAULT_TTL_SECONDSrbrrorjrrrrtr2r2r2r3r]s  C    rc@sTeZdZdZdZeeddZeeddZeeddZ ee ddZ eeZ eeZ dS)FullMd5LLMCacherfull_md5_llm_cacheTr)indexN)r}r~rrrrrid prompt_md5rrrrdrr2r2r2r3rs     rc@s^eZdZdZefd!ddZd"d dZd#ddZd$ddZd%ddZ d&ddZ e d'ddZ d S)(SQLAlchemyMd5CacherrrrType[FullMd5LLMCache]cCrrrrr2r2r3rbszSQLAlchemyMd5Cache.__init__rdr*rer+rfcCs"|||}|rdd|DSdS)rgcSrrr rr2r2r3r>rz-SQLAlchemyMd5Cache.lookup..N) _search_rows)rardrerr2r2r3rjs zSQLAlchemyMd5Cache.lookuprkrr\c sfddt|D}tj/}||D]}||q&Wdn1s8wYWddSWddS1sPwYdS)rc s2g|]\}}jttt||dqS))rrdrrrr)rr*uuiduuid1rrrerdrrar2r3r>!s  z-SQLAlchemyMd5Cache.update..N)_delete_previousget_md5rrrrrrr2rr3ros     PzSQLAlchemyMd5Cache.updatec Cst|jj|jj||k|jj|k|jj|k|jj }t |j 6}| | |}|D]}||q7Wdn1sIwYWddSWddS1sawYdSr)rrrrrrrrdrrrrrrrr)rardrerrrrr2r2r3r0s   Pz#SQLAlchemyMd5Cache._delete_previous List[Row]cCs||}t|jj|jj|k|jj|k|jj|k|jj }t |j }| | WdS1s-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 the collection is created. Defaults to the database's "default namespace". rrrr)rN)r%astra_dbcreate_collection collectionr)rarrrrr astra_envr2r2r3rbas zAstraDBCache.__init__rdrer+cCt|dt|SN#rrr2r2r3_make_idzAstraDBCache._make_idrfcCsT|||}|jjd|iddiddd}|dur(t|d}|dur&|SdSdS)rg_idrr)filter projectiondatarN)rrfind_onerZ)rardredoc_idrr6r2r2r3rjs"  zAstraDBCache.lookuprkrr\cCs*|||}t|}|j||ddS)rm)rrN)rrQrupsert)rardrerkrrr2r2r3ros zAstraDBCache.updaterrrrcCrrrrr2r2r3rrzAstraDBCache.delete_through_llmcCs|||}|j|dS)rN)rr delete_one)rardrerr2r2r3rs zAstraDBCache.deleterprcK|j|jdSrrtruncate_collectionrrsr2r2r3rtr5zAstraDBCache.clear) rr*rrXrrXrrrrXrrzr{rrrr|) r}r~rr&ASTRA_DB_CACHE_DEFAULT_COLLECTION_NAMErbrrrjrorrrtr2r2r2r3rVs  "    r langchain_astradb_semantic_cachec@seZdZdZedddddedd3ddZd4ddZed5ddZ d6ddZ d7d!d"Z d8d$d%Z d9d:d*d+Z d;d-d.Zd-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 the collection is created. Defaults to the database's "default namespace". embedding (Embedding): Embedding provider for semantic encoding and search. metric: the function to use for evaluating similarity of text embeddings. Defaults to 'cosine' (alternatives: 'euclidean', 'dot_product') similarity_threshold (float, optional): the minimum similarity for accepting a (semantic-search) match. The default score threshold is tuned to the default metric. Tune it carefully yourself if switching to another distance metric. rrrr*r+rcrrrrr`r2r3rrz7AstraDBSemanticCache.__init__.._cache_embedding)r dimensionrNr) r%rrrr r,ASTRA_DB_SEMANTIC_CACHE_EMBEDDING_CACHE_SIZErrrrrr) rarrrrrrrr rrr2r`r3rbs("  zAstraDBSemanticCache.__init__r+rcCrrrr`r2r2r3rrz-AstraDBSemanticCache._get_embedding_dimensionrdrecCrrrrr2r2r3rrzAstraDBSemanticCache._make_idrkrr\cCsB|||}t|}|j|d}t|}|j||||ddS)rmr)rrrz$vectorN)rr4rrQrr)rardrerkrrrrr2r2r3ros  zAstraDBSemanticCache.updaterfcCrrrrr2r2r3rj)rzAstraDBSemanticCache.lookuprcCsn|j|d}t|}|jj|d|iddgdd}|dus#|d|jkr%dSt|d}|dur5|d|fSdS) z Look up based on prompt and llm_string. If there are hits, return (document_id, cached_entry) for the top hit rrrrT)rrfieldsinclude_similarityNz $similarity)rr4rvector_find_oner rZ)rardrerrrr6r2r2r3r1s    z#AstraDBSemanticCache.lookup_with_idrrrrcCrrrrr2r2r3rNrz/AstraDBSemanticCache.lookup_with_id_through_llmrcCs|j|dS)rN)rrrr2r2r3rWsz*AstraDBSemanticCache.delete_by_document_idrprcKrrrrsr2r2r3rt_r5zAstraDBSemanticCache.clear)rr*rrXrrXrrrrXrrrrXr rrrr{rzrrrrr|)r}r~rrr)ASTRA_DB_SEMANTIC_CACHE_DEFAULT_THRESHOLDrbrrrrorjrrrrtr2r2r2r3r s( B     r )r)r*r+r*)r6rr+r*)rDr*r+r)rRr*r+rS)r>r?r@r*r+r\)rrJr+r\)jr __future__rr.r.rAloggingrrabcrdatetimer functoolsrtypingrrrr r r r r rr sqlalchemyrrrrrsqlalchemy.enginersqlalchemy.engine.basersqlalchemy.ormrrrsqlalchemy.ext.declarativelangchain_core.cachesrrlangchain_core.embeddingsr#langchain_core.language_models.llmsrrlangchain_core.load.dumprlangchain_core.load.loadr!langchain_core.outputsr"r#langchain_core.utilsr$%langchain_community.utilities.astradbr%&langchain_community.vectorstores.redisr'r getLogger__file__rWrS astrapy.dbr(cassandra.clusterCassandraSessionr4rCrNrQrZr[BaserrrrrrrrrrIrMrNrrrtrrrrrrrrrrrr r r2r2r2r3s    0                  '" 3 V29S  $e# Hh