diff --git a/README_Prometheus.md b/README_Prometheus.md
new file mode 100644
index 0000000..731f3fc
--- /dev/null
+++ b/README_Prometheus.md
@@ -0,0 +1,287 @@
+# Project Overview
+
+## Introduction
+
+This project is a lightweight blockchain implementation written in Python, focusing on core blockchain functionality including transaction processing, block management, and state tracking. It provides a bare-metal implementation of fundamental blockchain concepts, demonstrating the inner workings of a decentralized ledger system.
+
+## Purpose
+
+The project implements key blockchain components such as:
+- Transaction creation and signing
+- Block generation and validation
+- State management using a Merkle Patricia Trie
+- Basic cryptocurrency-like transaction handling
+
+## Target Audience
+
+This project is ideal for:
+- Blockchain and cryptocurrency enthusiasts
+- Developers learning blockchain architecture
+- Computer science students interested in distributed systems
+- Researchers exploring blockchain fundamentals
+
+## Key Components
+
+The blockchain implementation includes:
+- Transaction management (transactions.py)
+- Block creation and validation (blocks.py)
+- State tracking using a Trie data structure
+- Basic cryptographic operations using bitcoin tools
+- Minimal network interaction capabilities
+
+## Technical Highlights
+
+- Written in pure Python
+- Uses RLP (Recursive Length Prefix) encoding for data serialization
+- Implements core blockchain data structures
+- Supports basic transaction signing and verification
+- Provides a foundation for understanding blockchain mechanics
+
+Note: This is an educational/experimental implementation and is not intended for production use.
+
+## Getting Started
+
+### Prerequisites
+- Python 3.7+
+- pip (Python package manager)
+
+### Installation
+1. Clone the repository:
+```bash
+git clone https://github.com/your-repo/ethereum-tools.git
+cd ethereum-tools
+```
+
+2. Create a virtual environment (recommended):
+```bash
+python3 -m venv venv
+source venv/bin/activate  # On Windows, use `venv\Scripts\activate`
+```
+
+3. Install dependencies:
+```bash
+pip install -r requirements.txt  # Note: Create a requirements.txt file if not existing
+```
+
+### Running the Project
+You can interact with the various modules directly or import them into your Python projects:
+
+```python
+# Example imports
+from rlp import encode, decode
+from trie import Trie
+from transactions import Transaction
+```
+
+### Running Tests
+To run the project tests:
+```bash
+python -m unittest discover
+```
+
+### Notes
+- Ensure you have the necessary cryptographic libraries installed
+- This project is a low-level implementation of Ethereum-related data structures
+- For production use, consider additional error handling and security measures
+
+## Features / Capabilities
+
+The project provides a set of utility functions and classes for working with Ethereum-related data structures and transactions:
+
+### RLP (Recursive Length Prefix) Encoding/Decoding
+- Comprehensive RLP encoding and decoding functionality
+- Supports encoding/decoding of:
+  - Integers (non-negative)
+  - Strings
+  - Lists
+- Handles various length encodings for different data types
+- Provides binary conversion utilities
+
+### Transaction Handling
+- Full transaction object implementation with support for:
+  - Transaction creation
+  - Transaction parsing
+  - Transaction signing
+  - Transaction serialization
+
+Key Transaction Capabilities:
+- Create transactions with parameters:
+  - Nonce
+  - Recipient address
+  - Value
+  - Fee
+  - Data payload
+- Sign transactions using cryptographic keys
+- Serialize transactions to RLP format
+- Generate transaction hashes
+- Extract sender information
+
+### Parsing Utilities
+- Basic parsing functions for processing input data
+- Support for hexadecimal and binary data formats
+
+### Cryptographic Operations
+- SHA256 hashing
+- ECDSA signature generation and recovery
+- Public key derivation
+
+### Limitations and Considerations
+- Focuses on core transaction and encoding primitives
+- Designed for low-level Ethereum-related data manipulation
+- Requires additional libraries (pybitcointools) for some cryptographic operations
+
+#### Example Usage
+```python
+# Create a transaction
+tx = Transaction(nonce, to_address, value, fee, data)
+
+# Sign the transaction
+tx.sign(private_key)
+
+# Serialize the transaction
+serialized_tx = tx.hex_serialize()
+```
+
+## Project Structure
+
+The project is organized with the following key files:
+
+- `blocks.py`: Likely handles blockchain block-related operations
+- `manager.py`: Probable management of core system components
+- `parser.py`: Handles parsing of data or transactions
+- `processblock.py`: Processes individual blockchain blocks
+- `rlp.py`: Implementation of Recursive Length Prefix (RLP) encoding
+- `transactions.py`: Manages blockchain transaction-related functionality
+- `trie.py`: Implements Merkle Patricia Trie data structure
+- `trietest.py`: Contains tests for the trie implementation
+
+Key configuration and script files:
+- `README.md`: Primary project documentation
+- `README_Prometheus.md`: Additional documentation, possibly related to Prometheus monitoring
+
+The project appears to be focused on Ethereum-related functionality, with modules covering core blockchain data structures, encoding, and transaction processing.
+
+## Technologies Used
+
+### Programming Languages
+- Python 3.x
+
+### Major Libraries and Frameworks
+- `pybitcointools`: Cryptocurrency-related utilities and cryptographic functions
+- `rlp` (Recursive Length Prefix): Encoding/decoding library for Ethereum-like data structures
+- `leveldb`: Key-value storage library for managing persistent data
+- `hashlib`: Python standard library for cryptographic hashing
+
+### Core Technologies
+- Blockchain-related data structures (Block, Transaction, Merkle Trie)
+- Cryptographic operations (address generation, hashing)
+- Decentralized system components (transaction pool, state management)
+
+### Development Tools
+- Python standard libraries (re, sys)
+
+### Database
+- LevelDB: Used for object and state storage
+
+# Usage Examples
+
+## Address Generation
+Generate Ethereum addresses using a seed:
+```python
+from manager import genaddr
+
+# Generate an address with a seed
+private_key, address = genaddr("your_seed_string")
+print(f"Private Key: {private_key}")
+print(f"Address: {address}")
+```
+
+## Transaction Handling
+The project supports basic transaction management:
+```python
+from transactions import Transaction
+from manager import mainblk
+
+# Check transaction validity
+# (Note: This is a simplified example based on the project's implementation)
+sender_balance = mainblk.get_balance(sender_address)
+transaction_value = 10  # Example value
+transaction_fee = 1     # Example fee
+
+# Validate transaction
+if sender_balance >= transaction_value + transaction_fee:
+    # Create and process transaction
+    tx = Transaction(transaction_data)
+```
+
+## Blockchain Interaction
+Interact with the blockchain using the receive method:
+```python
+from manager import receive
+
+# Get object by hash
+obj = receive(['getobj', object_hash])
+
+# Get account balance
+balance = receive(['getbalance', account_address])
+
+# Get contract-related information
+contract_root = receive(['getcontractroot', contract_address])
+contract_size = receive(['getcontractsize', contract_address])
+```
+
+## Database Operations
+The project uses LevelDB for storage:
+```python
+from manager import db
+
+# Store an object in the database
+db.Put(object_hash, serialized_object)
+
+# Retrieve an object from the database
+retrieved_object = db.Get(object_hash)
+```
+
+**Note:** These examples are based on the project's source code and are meant to illustrate potential usage. Actual implementation may require additional context and error handling.
+
+## License
+
+This project is licensed under the MIT License. 
+
+The MIT License is a permissive free software license originating at the Massachusetts Institute of Technology. It allows for reuse within proprietary software provided that all copies of the licensed software include a copy of the MIT License terms and the copyright notice.
+
+For the full license text, please refer to the original Ethereum project's license terms at the [Ethereum GitHub repository](https://github.com/ethereum/pyethereum).
+
+Note: Always verify the specific licensing terms directly with the project maintainers or the official repository.
+
+## Additional Notes
+
+### Technical Considerations
+- This is a low-level Ethereum blockchain implementation in Python, focusing on core blockchain data structures and operations.
+- The implementation includes critical blockchain components such as blocks, transactions, and state management.
+- Current implementation has some TODO items, including Proof of Work (POW) verification.
+
+### Potential Limitations
+- The code appears to be an early or experimental implementation of Ethereum blockchain mechanics.
+- State management and transaction processing are handled through custom data structures like Trie.
+- Some verification mechanisms are partially implemented (e.g., root hash checks, but incomplete POW verification).
+
+### Development and Contribution
+- This project seems to be an educational or experimental blockchain implementation.
+- Developers interested in blockchain fundamentals or Ethereum internals may find this codebase instructive.
+- The code references an external repository at https://github.com/ethereum/pyethereum for the current version.
+
+### Security and Production Use
+- **Warning**: This implementation should NOT be considered production-ready.
+- Incomplete security checks and verification mechanisms make it unsuitable for real-world blockchain applications.
+- Use only for educational, research, or developmental purposes.
+
+### Performance Considerations
+- The implementation uses custom data structures like Trie for state management.
+- Serialization and hashing methods are provided for blockchain-specific operations.
+- Performance and optimization may vary compared to more mature blockchain implementations.
+
+### Compatibility
+- Designed to work with RLP (Recursive Length Prefix) encoding, a key Ethereum data serialization method.
+- Integrates with pybitcointools for cryptographic operations.
+- May require specific Python versions and dependencies not explicitly listed in this README.
\ No newline at end of file