chatgpt long term memory
v0.1.0
Das ChatGPT-Langzeitspeicherpaket ist ein leistungsstarkes Tool, mit dem Sie Ihre Projekte in die Lage versetzen können, eine große Anzahl gleichzeitiger Benutzer zu verwalten. Dies wird durch die nahtlose Integration einer umfangreichen Wissensdatenbank und eines adaptiven Speichers durch modernste Technologien wie GPT von OpenAI, Lama Vector Index und Redis Datastore erreicht. Mit diesem umfassenden Satz an Funktionen können Sie hoch skalierbare Anwendungen erstellen, die kontextrelevante und ansprechende Gespräche ermöglichen und so das gesamte Benutzererlebnis und die Interaktion verbessern.
Skalierbarkeit : Das ChatGPT-Langzeitspeicherpaket ist für die effiziente Handhabung zahlreicher gleichzeitiger Benutzer konzipiert und eignet sich daher für Anwendungen mit hoher Benutzernachfrage.
Umfangreiche Wissensdatenbank : Profitieren Sie von der Integration einer Wissensdatenbank, die es Ihnen ermöglicht, personalisierte Daten in Form von TXT-Dateien einzubinden. Diese Funktion ermöglicht es dem System, kontextrelevante Antworten bereitzustellen und sinnvolle Gespräche zu führen.
Adaptiver Speicher : Das Paket nutzt modernste Technologien wie GPT, Lama Vector Index und Redis-Datenspeicher, um ein adaptives Speichersystem zu gewährleisten. Diese Funktion ermöglicht eine verbesserte Leistung und kohärente Interaktionen, wodurch die Gespräche natürlicher und ansprechender werden.
Flexible Integration mit GPT-Modellen : Das Paket ermöglicht eine nahtlose Interaktion mit GPT-Modellen und gibt Ihnen die Möglichkeit, mithilfe des Kontextspeichers mit GPT-Modellen zu chatten. Dadurch können Sie mit modernsten Sprachmodellen für anspruchsvollere Sprachverarbeitungsaufgaben arbeiten.
Einfache Einrichtung und Konfiguration : Das Paket bietet einfache Installationsschritte mit pip , und Sie können Ihre Umgebung schnell mit Ihrem API-Schlüssel von OpenAI einrichten. Die Konfigurationsoptionen sind anpassbar, sodass Sie das Paket an Ihre spezifischen Projektanforderungen anpassen können.
Nutzung des Redis-Datenspeichers : Die Integration mit dem Redis-Datenspeicher gewährleistet eine effiziente Datenspeicherung und -abfrage und trägt zur allgemeinen Skalierbarkeit und Reaktionsfähigkeit des Systems bei.
API-Integration mit OpenAI : Das Paket nutzt die API von OpenAI, um seine GPT-basierten Funktionen zu unterstützen. Dies gewährleistet den Zugriff auf die neuesten Fortschritte in der Sprachverarbeitung und den Funktionen von GPT-Modellen.
Kontinuierliches Lernen und Verbessern : Als GPT-basiertes System profitiert das ChatGPT-Langzeitgedächtnispaket von kontinuierlichem Lernen und Verbessern und bleibt mit den neuesten Entwicklungen im Sprachverständnis und in der Generierung auf dem Laufenden.
Anpassbarer Konversationsablauf : Das Paket bietet anpassbare Konversationsabläufe mit der Möglichkeit, den Chatverlauf und die Wissensdatenbankdaten des Benutzers einzubeziehen. Dies verbessert das kontextuelle Verständnis und die Relevanz der Antworten.
Benutzerfreundliche Schnittstellen : Die bereitgestellten Codefragmente und Schnittstellen erleichtern Entwicklern die Integration des ChatGPT-Langzeitspeicherpakets in ihre Projekte, wodurch die Lernkurve minimiert und der Entwicklungsprozess optimiert wird.
Die Kombination dieser Schlüsselfunktionen macht das ChatGPT-Langzeitspeicherpaket zu einer wertvollen Ergänzung Ihrer Projekte und ermöglicht Ihnen die Erstellung interaktiver und dynamischer Konversationsanwendungen mit leistungsstarken Sprachverarbeitungsfunktionen.
Um das Chatgpt-Langzeitspeicherpaket in Ihren Projekten zu nutzen, führen Sie die folgenden Schritte aus:
pip install chatgpt_long_term_memory export OPENAI_API_kEY=sk-******Ziehen Sie das Redis-Docker-Image und führen Sie Folgendes aus:
docker pull redis
docker network create --subnet=172.0.0.0/16 mynet123
docker run --name redis-db -d --net mynet123 --ip 172.0.0.22 -p 6379:6379 -p 8001:8001 redis:latest
Sie können den Indexspeicher nutzen, indem Sie Knowledge_base=True festlegen, um Ihre personalisierten Daten in Form von TXT-Dateien einzubinden, die sich im Verzeichnis {Ihr_Stammpfad}/resources/data befinden. Stellen Sie die ordnungsgemäße Adressierung des Ressourcen-/Datenverzeichnisses sicher, um einen nahtlosen Zugriff auf die gespeicherten Daten zu gewährleisten.
# example/usage_index_memory.py
from utils import get_project_root
from chatgpt_long_term_memory . conversation import ChatGPTClient
from chatgpt_long_term_memory . llama_index_helpers import ( IndexConfig ,
RetrieversConfig )
from chatgpt_long_term_memory . memory import ChatMemoryConfig
# Get project's root path
root_path = get_project_root ()
"""
First:
Initialize llama indexes config to create a index from knowledge base and user's chat history.
The root_path specifies the directory where the index will be stored.
The knowledge_base flag specifies whether to index the knowledge base.
The model_name specifies the name of the language model to use for indexing.
The temperature parameter controls the randomness of the output.
The context_window parameter specifies the size of the context window to use for indexing.
The num_outputs parameter specifies the number of output tokens to generate for each input token.
The max_chunk_overlap parameter specifies the maximum overlap between chunks.
The chunk_size_limit parameter specifies the maximum size of a chunk.
"""
doc_indexer_config = IndexConfig (
root_path = f" { root_path } /example" ,
knowledge_base = True ,
model_name = "gpt-3.5-turbo" ,
temperature = 0 ,
context_window = 4096 ,
num_outputs = 700 ,
max_chunk_overlap = 0.5 ,
chunk_size_limit = 600
)
"""
Second:
# Initialize retrievers config to configure the retrievers class.
# The `top_k` parameter specifies the number of top-k documents to retrieve for each query.
# The `max_tokens` parameter specifies the maximum number of tokens to return for each document.
"""
retrievers_config = RetrieversConfig (
top_k = 7 ,
max_tokens = 1000
)
"""
Then:
Initialize chat memory config to configure the chat memory class.
The `redis_host` parameter specifies the hostname of the Redis server.
The `redis_port` parameter specifies the port of the Redis server.
"""
chat_memory_config = ChatMemoryConfig (
redis_host = "172.0.0.22" ,
redis_port = 6379
)
"""
Create a `ChatGPTClient` object to start the conversation.
The `doc_indexer_config` parameter specifies the configuration for the document indexer.
The `retrievers_config` parameter specifies the configuration for the retrievers.
The `chat_memory_config` parameter specifies the configuration for the chat memory.
"""
chatgpt_client = ChatGPTClient (
doc_indexer_config = doc_indexer_config ,
retrievers_config = retrievers_config ,
chat_memory_config = chat_memory_config
)
# Start a conversation with the user.
user_id = 1
while True :
# Get the user's input.
user_input = input ( "User Input:" )
# If the user enters "q", break out of the loop.
if user_input == "q" :
break
# Get the response from the chatbot.
index , response = chatgpt_client . converse ( user_input , user_id = user_id )
# Print the response to the user.
print ( response )In diesem Szenario können Sie keine eigene Datenbank verwenden, aber Sie können mit den GPT-Modellen interagieren und den Kontextspeicher verwenden.
# example/usage_context_memory.py
from utils import get_project_root
from chatgpt_long_term_memory . conversation import ChatbotClient
from chatgpt_long_term_memory . llama_index_helpers import ( IndexConfig ,
RetrieversConfig )
from chatgpt_long_term_memory . memory import ChatMemoryConfig
from chatgpt_long_term_memory . openai_engine import OpenAIChatConfig
# Get project's root path
root_path = get_project_root ()
"""
First:
Initialize llama indexes config to create a index from knowledge base and user's chat history.
The root_path specifies the directory where the index will be stored.
The knowledge_base flag specifies whether to index the knowledge base.
The model_name specifies the name of the language model to use for indexing.
The temperature parameter controls the randomness of the output.
The context_window parameter specifies the size of the context window to use for indexing.
The num_outputs parameter specifies the number of output tokens to generate for each input token.
The max_chunk_overlap parameter specifies the maximum overlap between chunks.
The chunk_size_limit parameter specifies the maximum size of a chunk.
"""
doc_indexer_config = IndexConfig (
root_path = f" { root_path } /example" ,
knowledge_base = True ,
model_name = "gpt-3.5-turbo" ,
temperature = 0 ,
context_window = 4096 ,
num_outputs = 700 ,
max_chunk_overlap = 0.5 ,
chunk_size_limit = 600
)
"""
Second:
# Initialize retrievers config to configure the retrievers class.
# The `top_k` parameter specifies the number of top-k documents to retrieve for each query.
# The `max_tokens` parameter specifies the maximum number of tokens to return for each document.
"""
retrievers_config = RetrieversConfig (
top_k = 7 ,
max_tokens = 1000
)
"""
Then:
Initialize chat memory config to configure the chat memory class.
The `redis_host` parameter specifies the hostname of the Redis server.
The `redis_port` parameter specifies the port of the Redis server.
"""
chat_memory_config = ChatMemoryConfig (
redis_host = "172.0.0.22" ,
redis_port = 6379
)
# Method 2: chat with gpt models, use context memory in this scenario you can't use your own db
openai_chatbot_config = OpenAIChatConfig (
model_name = "gpt-4" ,
max_tokens = 1000 ,
temperature = 0 ,
top_p = 1 ,
presence_penalty = 0 ,
frequency_penalty = 0 ,
# keep in mind if you change prompt, consider history and human input
prompt = """Assistant is a large language model trained by OpenAI.
Assistant is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, Assistant is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.
Assistant is constantly learning and improving, and its capabilities are constantly evolving. It is able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. Additionally, Assistant is able to generate its own text based on the input it receives, allowing it to engage in discussions and provide explanations and descriptions on a wide range of topics.
Overall, Assistant is a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist.
History: {}
Human: {}
Assistant:"""
)
# Initialize the chatbot client.
chat_app = ChatbotClient (
doc_indexer_config = doc_indexer_config ,
retrievers_config = retrievers_config ,
chat_memory_config = chat_memory_config ,
openai_chatbot_config = openai_chatbot_config
)
# Start a conversation with the user.
user_id = 2
while True :
# Get the user's input.
user_input = input ( "User Input:" )
# If the user enters "q", break out of the loop.
if user_input == "q" :
break
# Get the response from the chatbot.
index , response = chat_app . converse ( user_input , user_id = user_id )
# Print the response to the user.
print ( response )
