Cara Membuat Analis Portofolio Bertenaga AI Menggunakan LangGraph dan LangChain (Panduan Langkah demi Langkah)

Pendahuluan

Di era investasi modern ini, memiliki pemahaman yang mendalam tentang kinerja portofolio Anda sangat penting untuk mencapai tujuan keuangan Anda. Sementara metode tradisional memerlukan perhitungan manual dan analisis spreadsheet yang membosankan, kecerdasan buatan (AI) menawarkan cara yang lebih efisien dan berbasis data untuk menganalisis dan mengoptimalkan investasi Anda. Panduan ini akan memandu Anda melalui proses membangun analis portofolio bertenaga AI menggunakan LangGraph dan LangChain, dua kerangka kerja canggih yang memungkinkan Anda memanfaatkan kemampuan bahasa alami dan AI untuk pengambilan keputusan investasi yang cerdas.

Mengapa Menggunakan AI untuk Analisis Portofolio?

AI menghadirkan sejumlah manfaat signifikan untuk analisis portofolio, termasuk:

1. Analisis yang Ditingkatkan: AI dapat memproses sejumlah besar data keuangan, termasuk laporan pasar, berita, dan sentimen media sosial, untuk mengidentifikasi tren dan wawasan yang mungkin terlewatkan oleh analis manusia.
2. Pengambilan Keputusan yang Lebih Cerdas: Dengan menganalisis data secara komprehensif, AI dapat membantu Anda membuat keputusan investasi yang lebih tepat berdasarkan bukti dan prediksi daripada intuisi.
3. Efisiensi yang Ditingkatkan: AI mengotomatiskan tugas-tugas analisis portofolio, membebaskan Anda untuk fokus pada strategi dan perencanaan yang lebih tinggi.
4. Personalisasi: AI dapat menyesuaikan analisis dengan profil risiko dan tujuan investasi Anda yang unik.
5. Deteksi Anomali: AI dapat mendeteksi pola dan anomali yang tidak biasa dalam kinerja portofolio Anda, memperingatkan Anda tentang potensi masalah atau peluang.

Ikhtisar LangGraph dan LangChain

Sebelum kita menyelami implementasi, mari kita pahami peran LangGraph dan LangChain:

• LangGraph: LangGraph adalah kerangka kerja yang dirancang untuk membangun aplikasi AI yang kompleks yang melibatkan beberapa langkah dan interaksi. Ini memungkinkan Anda mendefinisikan alur kerja terstruktur, mengelola dependensi, dan mengotomatiskan proses pengambilan keputusan. Dalam konteks analis portofolio, LangGraph akan mengatur alur kerja dari masukan data, analisis, hingga output rekomendasi.
• LangChain: LangChain adalah kerangka kerja untuk mengembangkan aplikasi yang didukung oleh model bahasa. Ini menyediakan serangkaian alat dan abstraksi untuk berinteraksi dengan model bahasa besar (LLM), seperti OpenAI GPT-3 atau Google PaLM, dan mengintegrasikannya ke dalam aplikasi Anda. Dalam kasus ini, LangChain akan digunakan untuk memproses data keuangan, menghasilkan wawasan, dan memberikan rekomendasi investasi.

Prasyarat

Sebelum memulai, pastikan Anda memiliki hal berikut:

1. Pengetahuan Python Dasar: Keakraban dengan sintaks Python, struktur data, dan konsep pemrograman penting.
2. Akun OpenAI API: Anda akan memerlukan kunci API dari OpenAI untuk menggunakan model bahasa mereka (GPT-3 atau yang lebih baru).
3. Instalasi LangGraph dan LangChain: Instal pustaka yang diperlukan menggunakan pip:

   pip install langgraph langchain openai

4. Akses Data Portofolio: Anda perlu memiliki akses ke data portofolio Anda, baik melalui file CSV, API broker, atau database.

Langkah 1: Menyiapkan Lingkungan Anda

Buat direktori proyek dan atur lingkungan virtual untuk mengisolasi dependensi proyek Anda:

mkdir ai_portfolio_analyzer
cd ai_portfolio_analyzer
python -m venv venv
source venv/bin/activate  # Untuk Linux/macOS
venv\Scripts\activate  # Untuk Windows

Instal pustaka yang diperlukan seperti yang ditunjukkan sebelumnya:

pip install langgraph langchain openai pandas

Selain itu, instal `yfinance` untuk mengambil data pasar saham jika Anda berencana untuk melakukannya:

pip install yfinance

Langkah 2: Mempersiapkan Data Portofolio

Langkah ini melibatkan mengumpulkan dan memformat data portofolio Anda. Data ini biasanya mencakup:

• Simbol Ticker: Kode unik yang mengidentifikasi saham atau aset tertentu.
• Jumlah Saham: Jumlah saham yang Anda miliki untuk setiap aset.
• Harga Pembelian: Harga per saham saat Anda membeli aset.
• Tanggal Pembelian: Tanggal Anda membeli aset.

Anda dapat menyimpan data ini dalam file CSV, mengambilnya dari API broker, atau mengaksesnya dari database. Berikut adalah contoh cara memuat data portofolio dari file CSV menggunakan Pandas:

“`python
import pandas as pd

def load_portfolio_data(csv_file):
“””Loads portfolio data from a CSV file.

Args:
csv_file (str): Path to the CSV file containing portfolio data.

Returns:
pandas.DataFrame: DataFrame containing the portfolio data.
“””
try:
df = pd.read_csv(csv_file)
# Pastikan kolom yang diperlukan ada
required_columns = [‘Ticker’, ‘Shares’, ‘Purchase Price’, ‘Purchase Date’]
for col in required_columns:
if col not in df.columns:
raise ValueError(f”Column ‘{col}’ is missing from the CSV file.”)
return df
except FileNotFoundError:
print(f”Error: File not found at {csv_file}”)
return None
except ValueError as e:
print(f”Error: {e}”)
return None
except Exception as e:
print(f”An unexpected error occurred: {e}”)
return None

# Example usage
portfolio_data = load_portfolio_data(‘portfolio.csv’)
if portfolio_data is not None:
print(portfolio_data)
“`

Pastikan file CSV Anda memiliki kolom yang sesuai (“Ticker”, “Shares”, “Purchase Price”, “Purchase Date”).

Langkah 3: Mendapatkan Data Pasar Historis

Untuk menganalisis kinerja portofolio Anda, Anda memerlukan data pasar historis untuk setiap aset. Anda dapat menggunakan perpustakaan `yfinance` untuk mengambil data ini dari Yahoo Finance:

“`python
import yfinance as yf
import datetime

def get_historical_data(ticker, start_date, end_date=None):
“””
Fetches historical stock data using yfinance.

Args:
ticker (str): The stock ticker symbol (e.g., ‘AAPL’).
start_date (str): The start date for historical data (YYYY-MM-DD).
end_date (str, optional): The end date for historical data (YYYY-MM-DD). Defaults to today.

Returns:
pandas.DataFrame: DataFrame containing historical stock data, or None if an error occurred.
“””
if end_date is None:
end_date = datetime.date.today().strftime(“%Y-%m-%d”)

try:
data = yf.download(ticker, start=start_date, end=end_date)
if data.empty:
print(f”No data found for ticker {ticker} between {start_date} and {end_date}.”)
return None
return data
except Exception as e:
print(f”Error fetching data for {ticker}: {e}”)
return None

# Contoh Penggunaan
ticker = “AAPL”
start_date = “2023-01-01”
historical_data = get_historical_data(ticker, start_date)

if historical_data is not None:
print(historical_data.head())
“`

Fungsi ini mengambil data historis untuk ticker tertentu dalam rentang tanggal yang ditentukan.

Langkah 4: Menghitung Kinerja Portofolio

Selanjutnya, hitung kinerja portofolio Anda berdasarkan data historis. Ini melibatkan menghitung keuntungan atau kerugian untuk setiap aset dan secara keseluruhan.

“`python
def calculate_portfolio_performance(portfolio_data, historical_data):
“””
Calculates the portfolio performance based on historical data.

Args:
portfolio_data (pandas.DataFrame): DataFrame containing portfolio data (Ticker, Shares, Purchase Price, Purchase Date).
historical_data (dict): Dictionary where keys are ticker symbols and values are DataFrames of historical data.

Returns:
pandas.DataFrame: DataFrame containing the performance data for each asset.
“””
performance_data = []

for index, row in portfolio_data.iterrows():
ticker = row[‘Ticker’]
shares = row[‘Shares’]
purchase_price = row[‘Purchase Price’]
purchase_date = row[‘Purchase Date’]

if ticker not in historical_data:
print(f”No historical data found for {ticker}. Skipping.”)
continue

# Cari harga penutupan pada tanggal pembelian
try:
purchase_date = pd.to_datetime(purchase_date)
if purchase_date not in historical_data[ticker].index:
# Cari tanggal terdekat yang tersedia
purchase_date = historical_data[ticker].index.get_loc(purchase_date, method=’nearest’)
purchase_date = historical_data[ticker].index[purchase_date] # Dapatkan tanggal aktual
print(f”Purchase date {row[‘Purchase Date’]} not found for {ticker}. Using nearest date: {purchase_date.strftime(‘%Y-%m-%d’)}”)
closing_price_at_purchase = historical_data[ticker].loc[purchase_date][‘Close’]
except KeyError:
print(f”Error: Purchase date {row[‘Purchase Date’]} not found in historical data for {ticker}.”)
continue

# Harga saat ini (harga penutupan terakhir yang tersedia)
current_price = historical_data[ticker][‘Close’].iloc[-1]

# Hitung keuntungan/kerugian
profit_loss = (current_price – closing_price_at_purchase) * shares
total_investment = closing_price_at_purchase * shares
percentage_change = (profit_loss / total_investment) * 100 if total_investment else 0

performance_data.append({
‘Ticker’: ticker,
‘Shares’: shares,
‘Purchase Price’: closing_price_at_purchase,
‘Current Price’: current_price,
‘Profit/Loss’: profit_loss,
‘Percentage Change’: percentage_change
})

performance_df = pd.DataFrame(performance_data)
return performance_df
“`

Fungsi ini menghitung keuntungan atau kerugian untuk setiap aset di portofolio Anda.

Langkah 5: Mengintegrasikan LangChain untuk Analisis dan Wawasan

Di sinilah LangChain masuk untuk memberikan wawasan dan rekomendasi cerdas. Pertama, siapkan kunci API OpenAI Anda:

“`python
import os
os.environ[“OPENAI_API_KEY”] = “YOUR_OPENAI_API_KEY” # Ganti dengan kunci API Anda yang sebenarnya
“`

Kemudian, gunakan LangChain untuk membuat rantai yang dapat menganalisis kinerja portofolio dan menghasilkan wawasan:

“`python
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

def generate_portfolio_insights(performance_data):
“””
Generates portfolio insights using LangChain and OpenAI.

Args:
performance_data (pandas.DataFrame): DataFrame containing portfolio performance data.

Returns:
str: A string containing the generated portfolio insights.
“””

llm = OpenAI(temperature=0.7) # Anda dapat menyesuaikan suhu untuk variasi keluaran
template = “””You are a financial advisor analyzing a portfolio. Given the following performance data:

{portfolio_data}

Provide a concise summary of the portfolio’s overall performance, highlighting key winners and losers. Also suggest potential areas for improvement and diversification. Be clear and actionable.
“””

prompt = PromptTemplate(
input_variables=[“portfolio_data”],
template=template
)

chain = LLMChain(llm=llm, prompt=prompt)

portfolio_summary = performance_data.to_string() # Mengonversi DataFrame ke string
insights = chain.run(portfolio_data=portfolio_summary)
return insights
“`

Fungsi ini menggunakan OpenAI untuk menghasilkan ringkasan kinerja portofolio dan saran.

Langkah 6: Membangun Alur Kerja LangGraph

Sekarang, mari kita integrasikan semuanya ke dalam alur kerja LangGraph. Ini melibatkan mendefinisikan node dan tepi yang mewakili berbagai langkah dalam proses analisis portofolio.

“`python
from langgraph.graph import StateGraph, END
from typing import TypedDict, Dict, Any

class GraphState(TypedDict):
portfolio_data: pd.DataFrame
historical_data: Dict[str, pd.DataFrame]
performance_data: pd.DataFrame
insights: str

def get_historical_data_for_portfolio(state: GraphState):
“””Fetches historical data for all tickers in the portfolio.”””
portfolio_data = state[‘portfolio_data’]
historical_data = {}
for ticker in portfolio_data[‘Ticker’].unique():
# Dapatkan tanggal pembelian terawal dari data portofolio
start_date = portfolio_data[portfolio_data[‘Ticker’] == ticker][‘Purchase Date’].min()
historical_data[ticker] = get_historical_data(ticker, start_date)
return {“historical_data”: historical_data}

def calculate_performance(state: GraphState):
“””Calculates portfolio performance.”””
portfolio_data = state[‘portfolio_data’]
historical_data = state[‘historical_data’]
performance_data = calculate_portfolio_performance(portfolio_data, historical_data)
return {“performance_data”: performance_data}

def generate_insights(state: GraphState):
“””Generates portfolio insights using LangChain.”””
performance_data = state[‘performance_data’]
insights = generate_portfolio_insights(performance_data)
return {“insights”: insights}

# Definisikan graph
graph = StateGraph(GraphState)

# Tambahkan node
graph.add_node(“get_data”, get_historical_data_for_portfolio)
graph.add_node(“calculate_performance”, calculate_performance)
graph.add_node(“generate_insights”, generate_insights)

# Tetapkan entri point
graph.set_entry_point(“get_data”)

# Hubungkan node
graph.add_edge(“get_data”, “calculate_performance”)
graph.add_edge(“calculate_performance”, “generate_insights”)
graph.add_edge(“generate_insights”, END) #akhir dari graf

# Kompilasi graph
app = graph.compile()

“`

Kode ini mendefinisikan alur kerja LangGraph dengan tiga node: `get_data`, `calculate_performance`, dan `generate_insights`. Ini menentukan bagaimana data mengalir di antara node ini.

Langkah 7: Menjalankan Alur Kerja

Terakhir, jalankan alur kerja LangGraph dengan data portofolio Anda:

“`python
# Muat data portofolio
portfolio_data = load_portfolio_data(‘portfolio.csv’)

# Pastikan data portofolio berhasil dimuat
if portfolio_data is None:
print(“Failed to load portfolio data. Exiting.”)
exit()

# Persiapkan data input untuk graph
inputs = {“portfolio_data”: portfolio_data, “historical_data”: {}}

# Jalankan graph
result = app.invoke(inputs)

# Cetak hasil
print(“Portfolio Insights:”)
print(result[‘insights’])
“`

Kode ini memuat data portofolio, menyiapkan input, menjalankan alur kerja LangGraph, dan mencetak wawasan yang dihasilkan.

Langkah 8: Menampilkan Hasil (Opsi)

Untuk visualisasi yang lebih baik, Anda dapat menggunakan pustaka seperti Matplotlib atau Seaborn untuk membuat grafik dan bagan yang menampilkan kinerja portofolio Anda. Anda juga dapat mengintegrasikan antarmuka pengguna web menggunakan kerangka kerja seperti Flask atau Streamlit untuk membuat aplikasi yang lebih interaktif.

Berikut adalah contoh sederhana menggunakan matplotlib:

“`python
import matplotlib.pyplot as plt

def visualize_performance(performance_data):
“””Visualizes portfolio performance using matplotlib.”””
if performance_data is None or performance_data.empty:
print(“No performance data to visualize.”)
return

plt.figure(figsize=(12, 6))
plt.bar(performance_data[‘Ticker’], performance_data[‘Percentage Change’], color=’skyblue’)
plt.xlabel(‘Ticker’)
plt.ylabel(‘Percentage Change (%)’)
plt.title(‘Portfolio Performance by Asset’)
plt.xticks(rotation=45, ha=’right’) # Putar label untuk keterbacaan
plt.tight_layout()
plt.show()
“`

Panggil fungsi ini dengan `visualize_performance(result[‘performance_data’])` setelah alur kerja selesai.

Optimasi dan Pertimbangan Lebih Lanjut

• Penyetelan Hyperparameter: Bereksperimen dengan suhu dan parameter lain dari model bahasa untuk mengoptimalkan kualitas wawasan yang dihasilkan.
• Integrasi API Broker: Terhubung langsung ke API broker Anda untuk mendapatkan data portofolio real-time dan mengotomatiskan proses perdagangan.
• Manajemen Risiko: Gabungkan metrik risiko seperti Volatilitas dan Sharpe Ratio ke dalam analisis Anda.
• Diversifikasi: Optimalkan portofolio Anda untuk diversifikasi berdasarkan profil risiko dan tujuan investasi Anda.
• Umpan Balik Pengguna: Menerapkan mekanisme umpan balik untuk memungkinkan pengguna memberikan umpan balik tentang keakuratan dan kegunaan wawasan yang dihasilkan AI.

Kesimpulan

Dengan mengikuti panduan langkah demi langkah ini, Anda telah berhasil membangun analis portofolio bertenaga AI menggunakan LangGraph dan LangChain. Anda sekarang dapat memanfaatkan kekuatan AI untuk mendapatkan wawasan yang lebih dalam tentang kinerja portofolio Anda, membuat keputusan investasi yang lebih cerdas, dan mencapai tujuan keuangan Anda. Ingatlah bahwa ini hanyalah titik awal, dan Anda dapat terus meningkatkan analis Anda dengan menambahkan fitur baru, menyempurnakan algoritma, dan mengintegrasikan sumber data tambahan.

Dengan kemajuan yang terus berlanjut dalam AI dan pemrosesan bahasa alami, masa depan analisis portofolio menjanjikan untuk menjadi lebih otomatis, personal, dan berbasis data.