llm elasticsearch cache

Wichtig

Diese Bibliothek ist jetzt Teil von Langchain, folgen Sie der offiziellen Dokumentation, z. B. für den LLM -Cache

LLM-ELASTICSECHSECHEN-CACHE

Eine Caching -Schicht für LLMs, die Elasticsearch ausnutzt, die mit Langchain -Caching vollständig kompatibel ist, sowohl für Chat- als auch für Embettdings -Modelle.

Installieren

pip install llm-elasticsearch-cache

Chat -Cache -Nutzung

Der Langchain -Cache kann ähnlich wie die anderen Cache -Integrationen verwendet werden.

Grundlegendes Beispiel

 from langchain . globals import set_llm_cache
from llmescache . langchain import ElasticsearchCache
from elasticsearch import Elasticsearch

es_client = Elasticsearch ( hosts = "http://localhost:9200" )
set_llm_cache (
    ElasticsearchCache (
        es_client = es_client , 
        es_index = "llm-chat-cache" , 
        metadata = { "project" : "my_chatgpt_project" }
    )
)

Der es_index -Parameter kann auch Aliase annehmen. Dies ermöglicht die Verwendung des ILM: Verwalten des Indexlebenszyklus, den wir für die Verwaltung der Retention und zur Kontrolle des Cache -Wachstums in Betracht ziehen können.

Schauen Sie sich die Klassendocstring für alle Parameter an.

Index den generierten Text

Die zwischengespeicherten Daten sind standardmäßig nicht durchsucht. Der Entwickler kann das Erstellen des Elasticsearch -Dokuments anpassen, um indizierte Textfelder hinzuzufügen, wobei beispielsweise den von der LLM generierten Text eingesetzt werden soll.

Dies kann durch Subklassifizieren von End -Overried -Methoden erfolgen. Die neue Cache-Klasse kann auch auf einen bereits bestehenden Cache-Index angewendet werden:

 from llmescache . langchain import ElasticsearchCache
from elasticsearch import Elasticsearch
from langchain_core . caches import RETURN_VAL_TYPE
from typing import Any , Dict , List
from langchain . globals import set_llm_cache
import json


class SearchableElasticsearchCache ( ElasticsearchCache ):

    @ property
    def mapping ( self ) -> Dict [ str , Any ]:
        mapping = super (). mapping
        mapping [ "mappings" ][ "properties" ][ "parsed_llm_output" ] = { "type" : "text" , "analyzer" : "english" }
        return mapping
    
    def build_document ( self , prompt : str , llm_string : str , return_val : RETURN_VAL_TYPE ) -> Dict [ str , Any ]:
        body = super (). build_document ( prompt , llm_string , return_val )
        body [ "parsed_llm_output" ] = self . _parse_output ( body [ "llm_output" ])
        return body

    @ staticmethod
    def _parse_output ( data : List [ str ]) -> List [ str ]:
        return [ json . loads ( output )[ "kwargs" ][ "message" ][ "kwargs" ][ "content" ] for output in data ]


es_client = Elasticsearch ( hosts = "http://localhost:9200" )
set_llm_cache ( SearchableElasticsearchCache ( es_client = es_client , es_index = "llm-chat-cache" ))

Einbettung Cache -Nutzung

Zwischenbettendings werden unter Verwendung der CacheBackedembedings auf etwas andere Weise erhalten als die offizielle Dokumentation.

 from llmescache . langchain import ElasticsearchStore
from elasticsearch import Elasticsearch
from langchain . embeddings import CacheBackedEmbeddings
from langchain_openai import OpenAIEmbeddings

es_client = Elasticsearch ( hosts = "http://localhost:9200" )

underlying_embeddings = OpenAIEmbeddings ( model = "text-embedding-3-small" )
store = ElasticsearchStore (
    es_client = es_client , 
    es_index = "llm-embeddings-cache" ,
    namespace = underlying_embeddings . model ,
    metadata = { "project" : "my_llm_project" }
)
cached_embeddings = CacheBackedEmbeddings (
    underlying_embeddings , 
    store
)

Ähnlich wie beim Chat -Cache kann man ElasticsearchStore unterklassen, um Vektoren für die Suche zu indizieren.

 from llmescache . langchain import ElasticsearchStore
from typing import Any , Dict , List

class SearchableElasticsearchStore ( ElasticsearchStore ):

    @ property
    def mapping ( self ) -> Dict [ str , Any ]:
        mapping = super (). mapping
        mapping [ "mappings" ][ "properties" ][ "vector" ] = { "type" : "dense_vector" , "dims" : 1536 , "index" : True , "similarity" : "dot_product" }
        return mapping
    
    def build_document ( self , llm_input : str , vector : List [ float ]) -> Dict [ str , Any ]:
        body = super (). build_document ( llm_input , vector )
        body [ "vector" ] = vector
        return body

Beachten Sie, dass CacheBackedEmbeddings derzeit keine Caching -Abfragen unterstützt. Dies bedeutet, dass Textfragen für Vektorsuche nicht zwischengespeichert werden. Durch Überschreiben der embed_query -Methode sollte man sie jedoch einfach implementieren können.