Navigating Nepal's complex financial landscape can be challenging for investors, especially when considering the numerous factors that influence market trends. As someone who has worked with financial data in Nepal, I've seen firsthand how difficult it can be to make informed investment decisions without the right tools and strategies. In this post, we'll explore how to use Python and generative AI agents to create more effective investment strategies that take into account the country's unique financial landscape. By leveraging real-time data analysis and AI-driven insights, investors can make more informed decisions and stay ahead of the curve.
Key Takeaways
- Utilize Python and generative AI agents to create more informed and effective investment strategies.
- Leverage real-time data analysis to stay ahead of market trends.
- Consider the unique factors that influence Nepal's financial landscape when making investment decisions.
The Problem
For investors in Nepal, navigating the country's complex financial landscape can be daunting. With numerous factors influencing market trends, it can be difficult to make informed investment decisions without the right tools and strategies. This post addresses the need for a more sophisticated investment approach that incorporates real-time data analysis and AI-driven insights.
Data and Sources
The post will utilize real-time data from the Nepal Stock Exchange (NEPSE) API, specifically the endpoint for retrieving historical stock prices (https://www.nepse.tms.com.np/api/). Data accessed on 2026-07-09.
Loading the Data
To start, we need to fetch the historical stock prices from the NEPSE API. We can use the `requests` library in Python to send a GET request to the API endpoint.
import requests
response = requests.get("https://www.nepse.tms.com.np/api/historical-stock-prices")
data = response.json()
Feature Engineering
Once we have the historical stock prices, we need to engineer features that can be used to train our AI model. This can include technical indicators such as moving averages and relative strength index (RSI).
import pandas as pd
import numpy as np
# Calculate moving averages
data['MA_50'] = data['Close'].rolling(window=50).mean()
data['MA_200'] = data['Close'].rolling(window=200).mean()
# Calculate RSI
delta = data['Close'].diff()
up, down = delta.copy(), delta.copy()
up[up < 0] = 0
down[down > 0] = 0
roll_up = up.rolling(window=14).mean()
roll_down = down.rolling(window=14).mean().abs()
RS = roll_up / roll_down
RSI = 100.0 - (100.0 / (1.0 + RS))
data['RSI'] = RSI
Model Training
With our features engineered, we can now train our AI model using a generative AI agent. For this example, we'll use a simple neural network.
from sklearn.neural_network import MLPRegressor
from sklearn.model_selection import train_test_split
# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(data.drop('Close', axis=1), data['Close'], test_size=0.2, random_state=42)
# Train model
model = MLPRegressor(hidden_layer_sizes=(50, 50), max_iter=1000)
model.fit(X_train, y_train)
Model Evaluation
Once our model is trained, we can evaluate its performance using metrics such as mean squared error (MSE) and R-squared.
from sklearn.metrics import mean_squared_error, r2_score
# Make predictions
y_pred = model.predict(X_test)
# Calculate MSE and R-squared
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)
print(f'MSE: {mse}, R-squared: {r2}')
Putting It Together
Now that we have our model trained and evaluated, we can use it to make predictions on new, unseen data. We can also use it to backtest our investment strategy and evaluate its performance over time.
if __name__ == "__main__":
data = load_data()
X_train, X_test, y_train, y_test = train_test_split(data.drop('Close', axis=1), data['Close'], test_size=0.2, random_state=42)
model = train_model(X_train, y_train)
y_pred = model.predict(X_test)
print(f'MSE: {mean_squared_error(y_test, y_pred)}, R-squared: {r2_score(y_test, y_pred)}')
Complete Script
The full runnable script combining all steps:
#!/usr/bin/env python3
import requests
import pandas as pd
import numpy as np
from sklearn.neural_network import MLPRegressor
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score
def load_data():
response = requests.get("https://www.nepse.tms.com.np/api/historical-stock-prices")
data = response.json()
return pd.DataFrame(data)
def train_model(X_train, y_train):
model = MLPRegressor(hidden_layer_sizes=(50, 50), max_iter=1000)
model.fit(X_train, y_train)
return model
if __name__ == "__main__":
data = load_data()
data['MA_50'] = data['Close'].rolling(window=50).mean()
data['MA_200'] = data['Close'].rolling(window=200).mean()
delta = data['Close'].diff()
up, down = delta.copy(), delta.copy()
up[up < 0] = 0
down[down > 0] = 0
roll_up = up.rolling(window=14).mean()
roll_down = down.rolling(window=14).mean().abs()
RS = roll_up / roll_down
RSI = 100.0 - (100.0 / (1.0 + RS))
data['RSI'] = RSI
X_train, X_test, y_train, y_test = train_test_split(data.drop('Close', axis=1), data['Close'], test_size=0.2, random_state=42)
model = train_model(X_train, y_train)
y_pred = model.predict(X_test)
print(f'MSE: {mean_squared_error(y_test, y_pred)}, R-squared: {r2_score(y_test, y_pred)}')
Expected Output
When you run the script, you should see the mean squared error (MSE) and R-squared values printed to the console. These values will give you an idea of how well the model is performing.
Limitations and Tradeoffs
While this approach can be effective, there are some limitations and tradeoffs to consider. For example, the model is only trained on historical data and may not generalize well to new, unseen data. Additionally, the model is sensitive to the choice of hyperparameters and may require significant tuning to achieve optimal performance.
Frequently Asked Questions
What is the best way to handle missing data in the NEPSE API?
One way to handle missing data is to use imputation techniques such as mean or median imputation. However, this can be sensitive to the specific problem and data, and may require careful evaluation to ensure that the imputation method is appropriate.
How can I improve the performance of the model?
There are several ways to improve the performance of the model, including hyperparameter tuning, feature engineering, and ensemble methods. Hyperparameter tuning involves adjusting the model's hyperparameters to optimize its performance, while feature engineering involves creating new features that are more informative and relevant to the problem. Ensemble methods involve combining the predictions of multiple models to improve overall performance.
What are some potential applications of this approach?
This approach can be applied to a variety of problems in finance, including stock market prediction, portfolio optimization, and risk management. It can also be applied to other domains, such as economics, politics, and social sciences, where predictive modeling and data analysis are important.
What I'd Change
In conclusion, while this approach can be effective, there are some limitations and tradeoffs to consider. If I were to rebuild this project, I would focus on improving the model's performance and robustness, and exploring more advanced techniques such as deep learning and ensemble methods. I would also consider using more diverse and representative data sources, and evaluating the model's performance using more rigorous metrics and evaluation protocols.
