Refactor and improve

Author: soos3d

.env.sample

@@ -5,7 +5,7 @@ LANGUAGE_MODEL="gpt-3.5-turbo" # gpt-4 gpt-3.5-turbo
 
 # Deeplake vector DB
 ACTIVELOOP_TOKEN=""
-DATASET_PATH="./local_vector_db" # "hub://USER_ID/custom_dataset"  # Edit with your user id if you want to use the cloud db.
+DATASET_PATH="./chainstack_docs" # "hub://USER_ID/custom_dataset"  # Edit with your user id if you want to use the cloud db.
 
 # Scrape settings
 SITE_MAP="https://docs.chainstack.com/sitemap.xml"

.gitignore

@@ -1,8 +1,10 @@
 # Virtual env
 docs-chat/
 
+.DS_store
 # Vector DB
 local_vector_db/
+chainstack_docs/
 
 # Byte-compiled / optimized / DLL files
 __pycache__/

README.md

@@ -1,50 +1,62 @@
 # Chainctack docs chat bot
 
-MVP for docs specific chat bot.
+Simple CLI implemenation of a docs specific AI assistant. This project guides you to build an AI assistant for the Chainstack documentation using LangChain and Activeloop.
+
+Read the article for an in depth guide:
+
+- []()
 
 ## Requirements
 
 Before getting started, ensure you have the following:
 
-* [Python](https://www.python.org/downloads/) - Version 3.7 or newer is required.
-* An active account on OpenAI, along with an [OpenAI API key](https://platform.openai.com/account/api-keys).
-* A Deep Lake account, complete with a [Deep Lake API key](https://app.activeloop.ai/?utm_source=referral&utm_medium=platform&utm_campaign=signup_promo_settings&utm_id=plg).
+- [Python](https://www.python.org/downloads/) - Version 3.7 or newer is required.
+- An active account on OpenAI, along with an [OpenAI API key](https://platform.openai.com/account/api-keys).
+- An Activeloop account, complete with a [Activeloop API key](https://app.activeloop.ai/?utm_source=referral&utm_medium=platform&utm_campaign=signup_promo_settings&utm_id=plg).
 
 ## Project structure
 
-* `docs-chat` directory is a Python virtual environment
-* `main.py` scrapes pages and creates vector database.
-* `chat.py` accepts users queries.
+- `.env` stores secrets and configuration as environment variables.
+- `main.py` scrapes pages and creates vector database.
+- `chat.py` accepts users queries.
 
 ## Quickstart
 
 - Clone the repository
 
-- Create new Python virtual environment
+```sh
+git clone https://github.com/soos3d/chainstack-docs-chat.git
+```
 
 - Get into the project's directory
 
 ```sh
 cd chainstack-docs-chat
 ```
 
+- Create new Python virtual environment
+
+```sh
+python3 -m venv docs-chat
+```
+
 - Install dependencies
 
 ```sh
 pip install -r requirements.txt
 ```
 
-- Add API keys to `.env`
+- Add API keys and config to the `.env` file:
 
 ```env
-# OpenAI 
+# OpenAI
 OPENAI_API_KEY=""
 EMBEDDINGS_MODEL="text-embedding-ada-002"
 LANGUAGE_MODEL="gpt-3.5-turbo" # gpt-4 gpt-3.5-turbo
 
 # Deeplake vector DB
 ACTIVELOOP_TOKEN=""
-DATASET_PATH="./local_vector_db" # "hub://USER_ID/custom_dataset"  # Edit with your user id if you want to use the cloud db.
+DATASET_PATH="./chainstack_docs" # "hub://USER_ID/custom_dataset"  # Edit with your user id if you want to use the cloud db.
 
 # Scrape settings
 SITE_MAP="https://docs.chainstack.com/sitemap.xml"
@@ -69,55 +81,54 @@ Pyrhon3 chat.py
 Sample interaction using the GPT3.5-turbo model. Use GPT4 for better responses.
 
 ```
-Please enter your question (or 'quit' to stop): what are chainstack core pillars?
+Please enter your question (or 'quit' to stop): What are Chainstack core pillars?
+Chainstack's core pillars are:
+
+1. Unbeatable pricing: Chainstack offers competitive pricing options for its services. You can check their pricing options and use the pricing calculator on their website or contact them for more information.
+
+2. Unbounded performance: Chainstack does not impose rate limiting or hard caps on its services. This means that you can enjoy high-performance and scalability without any restrictions.
+
+3. Unlimited flexibility: Chainstack provides unlimited flexibility to its users. You can customize your node settings, such as the txpool.pricebump, and access additional node resources. They also offer load balancing and other customization options to meet your specific needs.
+
+++source++: https://docs.chainstack.com/docs/platform-introduction
+```
+
+```
+Please enter your question (or 'quit' to stop): How can I start using the Ethereum API with Chainstack?
+To start using the Ethereum API with Chainstack, you can follow these steps:
 
-Question: what are chainstack core pillars?
-Answer: Chainstack's core pillars are unbeatable pricing, unbounded performance, and unlimited flexibility.
+1. Sign up with Chainstack: Visit the Chainstack website and sign up for an account.
 
-Tokens Used: 1178
-        Prompt Tokens: 1160
-        Completion Tokens: 18
-Successful Requests: 1
-Total Cost (USD): $0.002356
+2. Deploy a node: Once you have signed up, deploy an Ethereum node on Chainstack. You can choose the network you want to deploy (such as the Ethereum Sepolia testnet) and configure the node according to your needs.
 
-Please enter your question (or 'quit' to stop): how can i start using the Ethereum API with chainstack?
+3. View node access and credentials: After deploying the node, you will be able to view the access details and credentials for your node. This includes the RPC URL, which you will need to connect to the network.
 
-Question: how can i start using the Ethereum API with chainstack?
-Answer: To use the Ethereum API with Chainstack, you need to follow these steps:
+4. Connect to the network: Use the RPC URL provided by Chainstack to connect to the Ethereum network. You can use libraries like web3.js to interact with the network and perform various operations such as reading the latest block number or sending transactions.
+
+By following these steps, you will be able to start using the Ethereum API with Chainstack and interact with the Ethereum network.
+
+++source++: https://docs.chainstack.com/docs/ethereum-tutorial-trust-fund-account-with-remix
+```
+
+```
+Please enter your question (or 'quit' to stop): What methods can I use to get ethereum blocks information?
+To get Ethereum blocks information, you can use the following methods:
 
-1. Sign up with Chainstack.
-2. Deploy an Ethereum RPC node.
-3. View your node access and credentials.
-4. Create an API key to authenticate your requests to the Chainstack API.
-5. Use tools such as curl or Postman to make manual requests to the Ethereum RPC node using JSON-RPC and the command line.
+1. eth_blockNumber: This method returns the number of the most recent block on the Ethereum blockchain.
 
-Once you have completed these steps, you can start using the Ethereum API to interact with the Ethereum blockchain and build your applications.
+2. eth_getBlockByHash: This method retrieves a block by its hash.
 
-Tokens Used: 1389
-        Prompt Tokens: 1266
-        Completion Tokens: 123
-Successful Requests: 2
-Total Cost (USD): $0.0027780000000000005
+3. eth_getBlockByNumber: This method retrieves a block by its number.
 
-Please enter your question (or 'quit' to stop): what methods can i use to get ethereum blocks information?
+4. eth_getBlockTransactionCountByHash: This method returns the number of transactions in a block given its hash.
 
-Question: what methods can i use to get ethereum blocks information?
-Answer: The following methods can be used to retrieve Ethereum block information when using the Ethereum API with Chainstack:
+5. eth_getBlockTransactionCountByNumber: This method returns the number of transactions in a block given its number.
 
-- eth_blockNumber
-- eth_getBlockByHash
-- eth_getBlockByNumber
-- eth_getBlockTransactionCountByHash
-- eth_getBlockTransactionCountByNumber
-- eth_newBlockFilter
+6. eth_newBlockFilter: This method creates a new filter that notifies you when a new block is added to the Ethereum blockchain.
 
-These methods allow developers to access specific block details such as the block's transactions, timestamp, height, header, and more.
+These methods allow you to access specific block details such as transactions, timestamp, height, header, and more.
 
-Tokens Used: 1846
-        Prompt Tokens: 1739
-        Completion Tokens: 107
-Successful Requests: 2
-Total Cost (USD): $0.0036920000000000004
+++source++: https://docs.chainstack.com/reference/ethereum-blocks-rpc-methods
 ```
 
- 
+> Note that this is a basic app and many improvements can be made.

chat.py

@@ -4,71 +4,86 @@
 from langchain.chat_models import ChatOpenAI
 from langchain.chains import ConversationalRetrievalChain
 from langchain.embeddings import OpenAIEmbeddings
-from langchain.callbacks import get_openai_callback
+from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
 
-# Load environment variables from .env file
-load_dotenv()
 
-# Set environment variables
-os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY')
-os.environ['ACTIVELOOP_TOKEN'] = os.getenv('ACTIVELOOP_TOKEN')
-language_model = os.getenv('LANGUAGE_MODEL')
+def load_environment_variables():
+    """Load environment variables from .env file."""
+    load_dotenv()
+    os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY')
+    os.environ['ACTIVELOOP_TOKEN'] = os.getenv('ACTIVELOOP_TOKEN')
 
-# Set DeepLake dataset path
-DEEPLAKE_PATH = os.getenv('DATASET_PATH')
+def initialize_embeddings():
+    """Initialize OpenAI embeddings and disallow special tokens."""
+    return OpenAIEmbeddings(disallowed_special=())
 
-# Initialize OpenAI embeddings and disallow special tokens
-EMBEDDINGS = OpenAIEmbeddings(disallowed_special=())
+def initialize_deeplake(embeddings):
+    """Initialize DeepLake vector store with OpenAI embeddings."""
+    return DeepLake(
+        dataset_path=os.getenv('DATASET_PATH'),
+        read_only=True,
+        embedding=embeddings,
+    )
 
-# Initialize DeepLake vector store with OpenAI embeddings
-deep_lake = DeepLake(
-    dataset_path=DEEPLAKE_PATH,
-    read_only=True,
-    embedding_function=EMBEDDINGS,
-)
+def initialize_retriever(deep_lake):
+    """Initialize retriever and set search parameters."""
+    retriever = deep_lake.as_retriever()
+    retriever.search_kwargs.update({
+        'distance_metric': 'cos',
+        'fetch_k': 100,
+        'maximal_marginal_relevance': True,
+        'k': 10,
+    })
+    return retriever
 
-# Initialize retriever and set search parameters
-retriever = deep_lake.as_retriever()
-retriever.search_kwargs.update({
-    'distance_metric': 'cos',
-    'fetch_k': 100,
-    'maximal_marginal_relevance': True,
-    'k': 10,
-})
+def initialize_chat_model():
+    """Initialize ChatOpenAI model."""
+    return ChatOpenAI(streaming=True, callbacks=[StreamingStdOutCallbackHandler()], model_name=os.getenv('LANGUAGE_MODEL'), temperature=0.0)
 
-# Initialize ChatOpenAI model
-model = ChatOpenAI(model_name=language_model, temperature=0.2) # gpt-3.5-turbo by default. Use gpt-4 for better and more accurate responses 
-
-# Initialize ConversationalRetrievalChain
-qa = ConversationalRetrievalChain.from_llm(model, retriever=retriever)
-
-# Initialize chat history
-chat_history = []
+def initialize_conversational_chain(model, retriever):
+    """Initialize ConversationalRetrievalChain."""
+    return ConversationalRetrievalChain.from_llm(model, retriever=retriever, return_source_documents=True)
 
 def get_user_input():
     """Get user input and handle 'quit' command."""
     question = input("\nPlease enter your question (or 'quit' to stop): ")
-    if question.lower() == 'quit':
-        return None
-    return question
+    return None if question.lower() == 'quit' else question
 
+# In case you want to format the result.
 def print_answer(question, answer):
     """Format and print question and answer."""
     print(f"\nQuestion: {question}\nAnswer: {answer}\n")
 
 def main():
     """Main program loop."""
+    load_environment_variables()
+    embeddings = initialize_embeddings()
+    deep_lake = initialize_deeplake(embeddings)
+    retriever = initialize_retriever(deep_lake)
+    model = initialize_chat_model()
+    qa = initialize_conversational_chain(model, retriever)
+
+    # In this case the chat history is stored in memory only
+    chat_history = []
+
     while True:
         question = get_user_input()
         if question is None:  # User has quit
             break
+        
+        # Get results based on question
+        result = qa({"question": question, "chat_history": chat_history})
+        chat_history.append((question, result['answer']))   
+
+        # Take the first source to display
+        first_document = result['source_documents'][0]
+        metadata = first_document.metadata
+        source = metadata['source']
 
-        # Display token usage and approximate costs
-        with get_openai_callback() as tokens_usage:
-            result = qa({"question": question, "chat_history": chat_history})
-            chat_history.append((question, result['answer']))
-            print_answer(question, result['answer'])
-            print(tokens_usage)
+        # We are streaming the response so no need to print those
+        #print(f"-> **Question**: {question}\n")
+        #print(f"**Answer**: {result['answer']}\n")
+        print(f"\n\n++source++: {source}")
 
 if __name__ == "__main__":
     main()