chatgpt long term memory
v0.1.0
Le package ChatGPT Long Term Memory est un outil puissant conçu pour donner à vos projets la possibilité de gérer un grand nombre d'utilisateurs simultanés. Il y parvient en intégrant de manière transparente une base de connaissances étendue et une mémoire adaptative grâce à des technologies de pointe telles que GPT d'OpenAI, l'index vectoriel Lama et la banque de données Redis. Grâce à cet ensemble complet de fonctionnalités, vous pouvez créer des applications hautement évolutives qui fournissent des conversations contextuellement pertinentes et engageantes, améliorant ainsi l'expérience et l'interaction globales de l'utilisateur.
Évolutivité : le package ChatGPT Long Term Memory est conçu pour gérer efficacement de nombreux utilisateurs simultanés, ce qui le rend adapté aux applications ayant une forte demande des utilisateurs.
Base de connaissances étendue : Bénéficiez de l'intégration d'une base de connaissances qui vous permet d'incorporer des données personnalisées sous forme de fichiers TXT. Cette fonctionnalité permet au système de fournir des réponses contextuellement pertinentes et d'engager des conversations significatives.
Mémoire adaptative : le package utilise des technologies de pointe telles que GPT, l'index vectoriel Lama et la banque de données Redis pour garantir un système de mémoire adaptative. Cette fonctionnalité permet des performances améliorées et des interactions cohérentes, rendant les conversations plus naturelles et plus engageantes.
Intégration flexible avec les modèles GPT : le package permet une interaction transparente avec les modèles GPT, vous donnant la possibilité de discuter avec les modèles GPT en utilisant la mémoire contextuelle. Cela vous permet d’utiliser des modèles linguistiques de pointe pour des tâches de traitement linguistique plus avancées.
Installation et configuration faciles : le package fournit des étapes d'installation simples à l'aide pip , et vous pouvez rapidement configurer votre environnement avec votre clé API d'OpenAI. Les options de configuration sont personnalisables, vous permettant d'adapter le package aux exigences spécifiques de votre projet.
Utilisation de Redis Datastore : L'intégration avec Redis Datastore garantit un stockage et une récupération efficaces des données, contribuant à l'évolutivité et à la réactivité globales du système.
Intégration de l'API avec OpenAI : le package exploite l'API d'OpenAI pour alimenter ses fonctionnalités basées sur GPT. Cela garantit l’accès aux dernières avancées en matière de traitement linguistique et aux capacités des modèles GPT.
Apprentissage et amélioration continus : en tant que système basé sur GPT, le package ChatGPT Long Term Memory bénéficie d'un apprentissage et d'une amélioration continus, restant à jour avec les derniers développements en matière de compréhension et de génération de langues.
Flux de conversation personnalisable : le package propose des flux de conversation personnalisables avec la possibilité d'inclure l'historique des discussions de l'utilisateur et les données de la base de connaissances. Cela améliore la compréhension contextuelle et la pertinence des réponses.
Interfaces faciles à utiliser : les extraits de code et les interfaces fournis permettent aux développeurs d'intégrer facilement le package ChatGPT Long Term Memory dans leurs projets, minimisant ainsi la courbe d'apprentissage et rationalisant le processus de développement.
La combinaison de ces fonctionnalités clés fait du package ChatGPT Long Term Memory un ajout précieux à vos projets, vous permettant de créer des applications conversationnelles interactives et dynamiques dotées de puissantes capacités de traitement du langage.
Pour utiliser le package Chatgpt Long Term Memory dans vos projets, suivez les étapes ci-dessous :
pip install chatgpt_long_term_memory export OPENAI_API_kEY=sk-******extrayez l'image du docker Redis et exécutez :
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
Vous pouvez exploiter la mémoire d'index en définissant knowledge_base=True pour incorporer vos données personnalisées sous la forme de fichiers TXT situés dans le répertoire : {your_root_path}/resources/data. Assurez le bon adressage du répertoire ressources/données pour un accès transparent aux données stockées.
# 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 )Dans ce scénario, vous ne pouvez pas utiliser votre propre base de données, mais vous pouvez interagir avec les modèles GPT et utiliser la mémoire contextuelle.
# 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 )
