chatgpt long term memory
v0.1.0
El paquete ChatGPT Long Term Memory es una poderosa herramienta diseñada para potenciar sus proyectos con la capacidad de manejar una gran cantidad de usuarios simultáneos. Lo logra integrando a la perfección una amplia base de conocimientos y memoria adaptativa a través de tecnologías de vanguardia como GPT de OpenAI, llama vector index y Redis datastore. Con este conjunto integral de capacidades, puede crear aplicaciones altamente escalables que proporcionen conversaciones contextualmente relevantes y atractivas, mejorando la experiencia y la interacción general del usuario.
Escalabilidad : el paquete ChatGPT Long Term Memory está diseñado para manejar numerosos usuarios simultáneos de manera eficiente, lo que lo hace adecuado para aplicaciones con una gran demanda de usuarios.
Amplia base de conocimientos : Benefíciese de la integración de una base de conocimientos que le permite incorporar datos personalizados en forma de archivos TXT. Esta característica permite que el sistema proporcione respuestas contextualmente relevantes y participe en conversaciones significativas.
Memoria adaptable : el paquete utiliza tecnologías de vanguardia como GPT, índice de vectores de llama y almacén de datos de Redis para garantizar un sistema de memoria adaptable. Esta capacidad permite un mejor rendimiento e interacciones coherentes, lo que hace que las conversaciones sean más naturales y atractivas.
Integración flexible con modelos GPT : el paquete permite una interacción perfecta con modelos GPT, brindándole la opción de chatear con modelos GPT utilizando la memoria contextual. Esto le permite interactuar con modelos de lenguaje de última generación para tareas de procesamiento del lenguaje más avanzadas.
Instalación y configuración sencillas : el paquete proporciona pasos de instalación simples usando pip y puede configurar rápidamente su entorno con su clave API de OpenAI. Las opciones de configuración son personalizables, lo que le permite adaptar el paquete a los requisitos específicos de su proyecto.
Utilización de Redis Datastore : la integración con Redis Datastore garantiza un almacenamiento y recuperación de datos eficientes, lo que contribuye a la escalabilidad general y la capacidad de respuesta del sistema.
Integración de API con OpenAI : el paquete aprovecha la API de OpenAI para potenciar sus funcionalidades basadas en GPT. Esto garantiza el acceso a los últimos avances en el procesamiento del lenguaje y las capacidades de los modelos GPT.
Aprendizaje y mejora continuos : como sistema basado en GPT, el paquete ChatGPT Long Term Memory se beneficia del aprendizaje y la mejora continuos, manteniéndose actualizado con los últimos avances en comprensión y generación de idiomas.
Flujo de conversación personalizable : el paquete ofrece flujos de conversación personalizables con la capacidad de incluir el historial de chat del usuario y los datos de la base de conocimientos. Esto mejora la comprensión contextual y la relevancia de las respuestas.
Interfaces fáciles de usar : los fragmentos de código y las interfaces proporcionados facilitan a los desarrolladores la integración del paquete ChatGPT Long Term Memory en sus proyectos, minimizando la curva de aprendizaje y agilizando el proceso de desarrollo.
La combinación de estas características clave hace que el paquete ChatGPT Long Term Memory sea una valiosa adición a sus proyectos, permitiéndole crear aplicaciones conversacionales interactivas y dinámicas con poderosas capacidades de procesamiento de lenguaje.
Para utilizar el paquete Chatgpt Long Term Memory en sus proyectos, siga los pasos a continuación:
pip install chatgpt_long_term_memory export OPENAI_API_kEY=sk-******extraiga la imagen de la ventana acoplable de Redis y ejecute:
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
Puede aprovechar la memoria de índice configurando Knowledge_base=True para incorporar sus datos personalizados en forma de archivos TXT ubicados dentro del directorio: {your_root_path}/resources/data. Garantice la dirección adecuada del directorio de recursos/datos para un acceso perfecto a los datos almacenados.
# 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 )En este escenario, no puede usar su propia base de datos, pero puede interactuar con los modelos GPT y usar la memoria de contexto.
# 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 )
