How to Build Trading Journal with Ollama: Performance Analysis and Improvement

# Download Ollama installer from ollama.ai
# Run the installer and follow setup wizard

# Download Ollama for macOS
# Drag to Applications folder

curl -fsSL https://ollama.ai/install.sh | sh

# Pull Llama 2 model (7B parameters - good balance of speed and accuracy)
ollama pull llama2

# Verify installation
ollama list

# trading_journal_setup.py
import sqlite3
import pandas as pd
from datetime import datetime

class TradingJournalDB:
    def __init__(self, db_path="trading_journal.db"):
        self.db_path = db_path
        self.init_database()
    
    def init_database(self):
        """Initialize database with trading tables"""
        conn = sqlite3.connect(self.db_path)
        
        # Create trades table
        conn.execute('''
            CREATE TABLE IF NOT EXISTS trades (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                date TEXT NOT NULL,
                symbol TEXT NOT NULL,
                side TEXT NOT NULL,  -- 'BUY' or 'SELL'
                quantity REAL NOT NULL,
                entry_price REAL NOT NULL,
                exit_price REAL,
                profit_loss REAL,
                fees REAL DEFAULT 0,
                strategy TEXT,
                notes TEXT,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
            )
        ''')
        
        # Create performance metrics table
        conn.execute('''
            CREATE TABLE IF NOT EXISTS performance_metrics (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                date TEXT NOT NULL,
                total_trades INTEGER,
                winning_trades INTEGER,
                losing_trades INTEGER,
                total_pnl REAL,
                win_rate REAL,
                avg_win REAL,
                avg_loss REAL,
                profit_factor REAL,
                max_drawdown REAL,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
            )
        ''')
        
        conn.commit()
        conn.close()
        print("Database initialized successfully")

# Initialize the database
journal_db = TradingJournalDB()

# trade_logger.py
import sqlite3
from datetime import datetime

class TradeLogger:
    def __init__(self, db_path="trading_journal.db"):
        self.db_path = db_path
    
    def add_trade(self, symbol, side, quantity, entry_price, 
                  exit_price=None, strategy="", notes=""):
        """Add a new trade to the journal"""
        conn = sqlite3.connect(self.db_path)
        
        # Calculate profit/loss if exit price provided
        profit_loss = None
        if exit_price:
            if side.upper() == 'BUY':
                profit_loss = (exit_price - entry_price) * quantity
            else:  # SELL (short position)
                profit_loss = (entry_price - exit_price) * quantity
        
        # Insert trade record
        conn.execute('''
            INSERT INTO trades (date, symbol, side, quantity, entry_price, 
                              exit_price, profit_loss, strategy, notes)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
        ''', (
            datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
            symbol.upper(),
            side.upper(),
            quantity,
            entry_price,
            exit_price,
            profit_loss,
            strategy,
            notes
        ))
        
        conn.commit()
        conn.close()
        print(f"Trade logged: {side} {quantity} {symbol} @ ${entry_price}")
    
    def close_trade(self, trade_id, exit_price, fees=0):
        """Close an existing trade with exit price"""
        conn = sqlite3.connect(self.db_path)
        
        # Get trade details
        trade = conn.execute(
            'SELECT side, quantity, entry_price FROM trades WHERE id = ?', 
            (trade_id,)
        ).fetchone()
        
        if trade:
            side, quantity, entry_price = trade
            
            # Calculate profit/loss
            if side == 'BUY':
                profit_loss = (exit_price - entry_price) * quantity - fees
            else:
                profit_loss = (entry_price - exit_price) * quantity - fees
            
            # Update trade record
            conn.execute('''
                UPDATE trades 
                SET exit_price = ?, profit_loss = ?, fees = ?
                WHERE id = ?
            ''', (exit_price, profit_loss, fees, trade_id))
            
            conn.commit()
            print(f"Trade {trade_id} closed. P&L: ${profit_loss:.2f}")
        
        conn.close()

# Usage example
logger = TradeLogger()
logger.add_trade("AAPL", "BUY", 100, 150.25, 155.50, "Breakout", "Strong volume")

# ollama_analyzer.py
import requests
import json
import pandas as pd
import sqlite3

class OllamaTradeAnalyzer:
    def __init__(self, model="llama2", db_path="trading_journal.db"):
        self.model = model
        self.db_path = db_path
        self.ollama_url = "http://localhost:11434/api/generate"
    
    def query_ollama(self, prompt):
        """Send prompt to Ollama and get response"""
        payload = {
            "model": self.model,
            "prompt": prompt,
            "stream": False
        }
        
        try:
            response = requests.post(self.ollama_url, json=payload)
            if response.status_code == 200:
                return response.json()['response']
            else:
                return f"Error: {response.status_code}"
        except Exception as e:
            return f"Connection error: {str(e)}"
    
    def get_trade_data(self, days=30):
        """Fetch recent trade data for analysis"""
        conn = sqlite3.connect(self.db_path)
        
        query = '''
            SELECT symbol, side, quantity, entry_price, exit_price, 
                   profit_loss, strategy, date
            FROM trades 
            WHERE exit_price IS NOT NULL 
            AND date >= date('now', '-{} days')
            ORDER BY date DESC
        '''.format(days)
        
        df = pd.read_sql_query(query, conn)
        conn.close()
        return df
    
    def analyze_performance(self, days=30):
        """Generate AI analysis of trading performance"""
        df = self.get_trade_data(days)
        
        if df.empty:
            return "No completed trades found for analysis."
        
        # Calculate key metrics
        total_trades = len(df)
        winning_trades = len(df[df['profit_loss'] > 0])
        losing_trades = len(df[df['profit_loss'] < 0])
        win_rate = (winning_trades / total_trades) * 100
        total_pnl = df['profit_loss'].sum()
        avg_win = df[df['profit_loss'] > 0]['profit_loss'].mean()
        avg_loss = df[df['profit_loss'] < 0]['profit_loss'].mean()
        
        # Create analysis prompt
        prompt = f"""
        Analyze this trading performance data and provide actionable insights:
        
        Trading Performance Summary:
        - Total Trades: {total_trades}
        - Winning Trades: {winning_trades}
        - Losing Trades: {losing_trades}
        - Win Rate: {win_rate:.1f}%
        - Total P&L: ${total_pnl:.2f}
        - Average Win: ${avg_win:.2f if not pd.isna(avg_win) else 0}
        - Average Loss: ${avg_loss:.2f if not pd.isna(avg_loss) else 0}
        
        Top Losing Trades:
        {df.nsmallest(3, 'profit_loss')[['symbol', 'strategy', 'profit_loss']].to_string()}
        
        Top Winning Trades:
        {df.nlargest(3, 'profit_loss')[['symbol', 'strategy', 'profit_loss']].to_string()}
        
        Please provide:
        1. Key strengths in the trading performance
        2. Main weaknesses to address
        3. Specific recommendations for improvement
        4. Risk management suggestions
        
        Keep the analysis concise and actionable.
        """
        
        return self.query_ollama(prompt)

# Initialize analyzer
analyzer = OllamaTradeAnalyzer()

def analyze_trading_patterns(self):
    """Identify patterns in trading behavior"""
    df = self.get_trade_data(90)  # 3 months of data
    
    if len(df) < 10:
        return "Insufficient data for pattern analysis."
    
    # Group by strategy
    strategy_performance = df.groupby('strategy').agg({
        'profit_loss': ['count', 'sum', 'mean'],
        'symbol': lambda x: ', '.join(x.unique()[:5])
    }).round(2)
    
    # Time-based analysis
    df['hour'] = pd.to_datetime(df['date']).dt.hour
    hourly_performance = df.groupby('hour')['profit_loss'].agg(['count', 'mean']).round(2)
    
    prompt = f"""
    Analyze these trading patterns and identify opportunities for optimization:
    
    Strategy Performance:
    {strategy_performance.to_string()}
    
    Hourly Trading Performance:
    {hourly_performance.to_string()}
    
    Most Traded Symbols:
    {df['symbol'].value_counts().head(10).to_string()}
    
    Please identify:
    1. Which strategies are most/least effective
    2. Optimal trading times based on performance
    3. Symbol-specific patterns or biases
    4. Recommendations for strategy allocation
    5. Potential overtrading or undertrading issues
    
    Provide specific, actionable insights.
    """
    
    return self.query_ollama(prompt)

# dashboard.py
import streamlit as st
import pandas as pd
import matplotlib.pyplot as plt
import sqlite3
from ollama_analyzer import OllamaTradeAnalyzer

def load_trade_data():
    """Load trade data from database"""
    conn = sqlite3.connect("trading_journal.db")
    df = pd.read_sql_query('''
        SELECT * FROM trades 
        WHERE exit_price IS NOT NULL 
        ORDER BY date DESC
    ''', conn)
    conn.close()
    return df

def create_performance_charts(df):
    """Create performance visualization charts"""
    if df.empty:
        st.warning("No trade data available for charts.")
        return
    
    # Equity curve
    df['cumulative_pnl'] = df['profit_loss'].cumsum()
    
    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8))
    
    # Cumulative P&L chart
    ax1.plot(range(len(df)), df['cumulative_pnl'], linewidth=2, color='blue')
    ax1.set_title('Equity Curve', fontsize=14, fontweight='bold')
    ax1.set_ylabel('Cumulative P&L ($)')
    ax1.grid(True, alpha=0.3)
    
    # Win/Loss distribution
    wins = df[df['profit_loss'] > 0]['profit_loss']
    losses = df[df['profit_loss'] < 0]['profit_loss']
    
    ax2.hist([wins, losses], bins=20, alpha=0.7, 
             label=['Wins', 'Losses'], color=['green', 'red'])
    ax2.set_title('Win/Loss Distribution', fontsize=14, fontweight='bold')
    ax2.set_xlabel('Profit/Loss ($)')
    ax2.set_ylabel('Frequency')
    ax2.legend()
    ax2.grid(True, alpha=0.3)
    
    plt.tight_layout()
    st.pyplot(fig)

def main():
    st.set_page_config(page_title="AI Trading Journal", layout="wide")
    
    st.title("🤖 AI-Powered Trading Journal with Ollama")
    st.markdown("---")
    
    # Sidebar
    st.sidebar.header("Navigation")
    page = st.sidebar.selectbox("Choose a page", 
                               ["Dashboard", "AI Analysis", "Add Trade", "Trade History"])
    
    if page == "Dashboard":
        st.header("📊 Performance Dashboard")
        
        df = load_trade_data()
        
        if not df.empty:
            # Key metrics
            col1, col2, col3, col4 = st.columns(4)
            
            with col1:
                st.metric("Total Trades", len(df))
            
            with col2:
                total_pnl = df['profit_loss'].sum()
                st.metric("Total P&L", f"${total_pnl:,.2f}")
            
            with col3:
                win_rate = (len(df[df['profit_loss'] > 0]) / len(df)) * 100
                st.metric("Win Rate", f"{win_rate:.1f}%")
            
            with col4:
                avg_trade = df['profit_loss'].mean()
                st.metric("Avg Trade", f"${avg_trade:.2f}")
            
            # Performance charts
            create_performance_charts(df)
        
        else:
            st.info("No trade data available. Add some trades to see your dashboard.")
    
    elif page == "AI Analysis":
        st.header("🧠 AI Performance Analysis")
        
        analyzer = OllamaTradeAnalyzer()
        
        col1, col2 = st.columns([1, 1])
        
        with col1:
            if st.button("🔍 Analyze Recent Performance", type="primary"):
                with st.spinner("AI is analyzing your trades..."):
                    analysis = analyzer.analyze_performance(30)
                    st.subheader("📈 Performance Insights")
                    st.write(analysis)
        
        with col2:
            if st.button("🎯 Identify Trading Patterns", type="primary"):
                with st.spinner("AI is finding patterns..."):
                    patterns = analyzer.analyze_trading_patterns()
                    st.subheader("🔄 Pattern Analysis")
                    st.write(patterns)

if __name__ == "__main__":
    main()

# Install required packages
pip install streamlit pandas matplotlib sqlite3

# Run the dashboard
streamlit run dashboard.py

def analyze_risk_management(self):
    """Analyze risk management practices"""
    df = self.get_trade_data(60)
    
    if df.empty:
        return "No data available for risk analysis."
    
    # Calculate position sizing metrics
    df['position_value'] = df['quantity'] * df['entry_price']
    avg_position_size = df['position_value'].mean()
    max_position_size = df['position_value'].max()
    min_position_size = df['position_value'].min()
    
    # Calculate drawdown
    df['cumulative_pnl'] = df['profit_loss'].cumsum()
    running_max = df['cumulative_pnl'].expanding().max()
    drawdown = df['cumulative_pnl'] - running_max
    max_drawdown = drawdown.min()
    
    # Risk-reward analysis
    df['risk_reward'] = abs(df[df['profit_loss'] > 0]['profit_loss']) / abs(df[df['profit_loss'] < 0]['profit_loss'].mean()) if len(df[df['profit_loss'] < 0]) > 0 else 0
    
    prompt = f"""
    Evaluate the risk management in this trading performance:
    
    Position Sizing Analysis:
    - Average Position Size: ${avg_position_size:,.2f}
    - Maximum Position Size: ${max_position_size:,.2f}
    - Minimum Position Size: ${min_position_size:,.2f}
    - Position Size Variation: {((max_position_size - min_position_size) / avg_position_size * 100):.1f}%
    
    Risk Metrics:
    - Maximum Drawdown: ${max_drawdown:,.2f}
    - Total Trades: {len(df)}
    - Consecutive Losses (max): {self.get_max_consecutive_losses(df)}
    
    Recent Largest Losses:
    {df.nsmallest(5, 'profit_loss')[['symbol', 'position_value', 'profit_loss']].to_string()}
    
    Assess:
    1. Position sizing consistency and appropriateness
    2. Risk exposure per trade
    3. Drawdown management effectiveness
    4. Recommendations for better risk control
    5. Signs of overrisk or emotional trading
    
    Provide specific risk management improvements.
    """
    
    return self.query_ollama(prompt)

def get_max_consecutive_losses(self, df):
    """Calculate maximum consecutive losses"""
    current_streak = 0
    max_streak = 0
    
    for _, trade in df.iterrows():
        if trade['profit_loss'] < 0:
            current_streak += 1
            max_streak = max(max_streak, current_streak)
        else:
            current_streak = 0
    
    return max_streak

def analyze_market_conditions(self):
    """Analyze performance in different market conditions"""
    df = self.get_trade_data(90)
    
    if len(df) < 20:
        return "Insufficient data for market condition analysis."
    
    # Add market condition indicators (simplified)
    df['date'] = pd.to_datetime(df['date'])
    df['week'] = df['date'].dt.week
    df['month'] = df['date'].dt.month
    
    # Performance by month
    monthly_performance = df.groupby('month').agg({
        'profit_loss': ['count', 'sum', 'mean'],
        'symbol': 'nunique'
    }).round(2)
    
    # Performance by day of week
    df['day_of_week'] = df['date'].dt.day_name()
    daily_performance = df.groupby('day_of_week')['profit_loss'].agg(['count', 'mean']).round(2)
    
    prompt = f"""
    Analyze trading performance across different market conditions and time periods:
    
    Monthly Performance:
    {monthly_performance.to_string()}
    
    Day of Week Performance:
    {daily_performance.to_string()}
    
    Strategy Performance by Symbol Count:
    {df.groupby('strategy')['symbol'].nunique().to_string()}
    
    Analyze:
    1. Seasonal patterns in performance
    2. Day-of-week effects on trading results
    3. Market condition adaptability
    4. Diversification across symbols and strategies
    5. Timing optimization opportunities
    
    Provide insights about when and how to trade more effectively.
    """
    
    return self.query_ollama(prompt)

# automated_reports.py
import schedule
import time
from datetime import datetime, timedelta
from ollama_analyzer import OllamaTradeAnalyzer

class AutomatedReports:
    def __init__(self):
        self.analyzer = OllamaTradeAnalyzer()
    
    def generate_weekly_report(self):
        """Generate comprehensive weekly trading report"""
        try:
            # Get current date
            today = datetime.now()
            report_date = today.strftime("%Y-%m-%d")
            
            # Generate AI analysis
            performance_analysis = self.analyzer.analyze_performance(7)
            pattern_analysis = self.analyzer.analyze_trading_patterns()
            risk_analysis = self.analyzer.analyze_risk_management()
            
            # Create comprehensive report
            report = f"""
# Weekly Trading Report - {report_date}

## Performance Summary
{performance_analysis}

## Pattern Analysis
{pattern_analysis}

## Risk Management Review
{risk_analysis}

## Action Items for Next Week
Based on the analysis above, focus on:
1. Addressing identified weaknesses
2. Leveraging successful patterns
3. Implementing risk management improvements
4. Monitoring suggested optimizations

Report generated automatically by AI Trading Journal
            """
            
            # Save report to file
            filename = f"reports/weekly_report_{report_date}.md"
            with open(filename, 'w') as f:
                f.write(report)
            
            print(f"Weekly report generated: {filename}")
            
        except Exception as e:
            print(f"Error generating weekly report: {e}")
    
    def setup_automated_reports(self):
        """Schedule automated report generation"""
        # Generate weekly report every Sunday at 9 AM
        schedule.every().sunday.at("09:00").do(self.generate_weekly_report)
        
        print("Automated reporting scheduled")
        
        # Keep the scheduler running
        while True:
            schedule.run_pending()
            time.sleep(3600)  # Check every hour

# Run automated reports
if __name__ == "__main__":
    reporter = AutomatedReports()
    reporter.setup_automated_reports()

class DataQualityChecker:
    def __init__(self, db_path="trading_journal.db"):
        self.db_path = db_path
    
    def validate_trade_data(self):
        """Check for data quality issues"""
        conn = sqlite3.connect(self.db_path)
        df = pd.read_sql_query('SELECT * FROM trades', conn)
        conn.close()
        
        issues = []
        
        # Check for missing exit prices
        open_trades = df[df['exit_price'].isna()]
        if len(open_trades) > 0:
            issues.append(f"Found {len(open_trades)} open trades without exit prices")
        
        # Check for unusual profit/loss values
        extreme_trades = df[abs(df['profit_loss']) > df['profit_loss'].std() * 3]
        if len(extreme_trades) > 0:
            issues.append(f"Found {len(extreme_trades)} trades with extreme P&L values")
        
        # Check for missing strategy tags
        no_strategy = df[df['strategy'].isna() | (df['strategy'] == '')]
        if len(no_strategy) > 0:
            issues.append(f"Found {len(no_strategy)} trades without strategy tags")
        
        return issues
    
    def clean_data(self):
        """Automatically fix common data issues"""
        conn = sqlite3.connect(self.db_path)
        
        # Fill missing strategy with 'Untagged'
        conn.execute('''
            UPDATE trades 
            SET strategy = 'Untagged' 
            WHERE strategy IS NULL OR strategy = ''
        ''')
        
        conn.commit()
        conn.close()
        print("Data cleaning completed")

def optimize_ollama_performance(self):
    """Configure Ollama for optimal performance"""
    # Use shorter prompts for faster processing
    def create_efficient_prompt(self, data_summary):
        """Create concise prompts for faster AI processing"""
        return f"""
        Quick analysis needed for trading data:
        {data_summary}
        
        Provide 3 key insights:
        1. Main strength
        2. Main weakness  
        3. Top improvement action
        
        Keep response under 100 words.
        """
    
    # Cache frequently used analyses
    def cache_analysis_results(self, analysis_type, result):
        """Cache analysis results to avoid redundant API calls"""
        cache_key = f"{analysis_type}_{datetime.now().strftime('%Y-%m-%d')}"
        # Implementation depends on your caching solution
        pass

def diagnose_ollama_connection(self):
    """Diagnose and fix Ollama connection issues"""
    try:
        # Test basic connection
        response = requests.get("http://localhost:11434/api/tags", timeout=5)
        if response.status_code == 200:
            print("✅ Ollama server is running")
            
            # Check available models
            models = response.json().get('models', [])
            if models:
                print(f"✅ Available models: {[m['name'] for m in models]}")
            else:
                print("⚠️ No models installed. Run: ollama pull llama2")
        else:
            print(f"❌ Ollama server error: {response.status_code}")
            
    except requests.exceptions.ConnectionError:
        print("❌ Cannot connect to Ollama. Ensure it's running on port 11434")
        print("💡 Start Ollama with: ollama serve")
        
    except requests.exceptions.Timeout:
        print("❌ Ollama server timeout. Check system resources")
        print("💡 Consider using a smaller model like llama2:7b")

# Add to your analyzer class
def test_system_health(self):
    """Run comprehensive system health check"""
    self.diagnose_ollama_connection()
    
    # Test database connection
    try:
        conn = sqlite3.connect(self.db_path)
        conn.execute('SELECT COUNT(*) FROM trades').fetchone()
        conn.close()
        print("✅ Database connection successful")
    except Exception as e:
        print(f"❌ Database error: {e}")
    
    # Test data availability
    df = self.get_trade_data(30)
    if len(df) > 0:
        print(f"✅ Found {len(df)} trades for analysis")
    else:
        print("⚠️ No trade data found. Add some trades first")

def optimize_for_large_datasets(self):
    """Handle large trading datasets efficiently"""
    # Process data in chunks
    def analyze_in_batches(self, batch_size=100):
        """Analyze trades in smaller batches"""
        conn = sqlite3.connect(self.db_path)
        total_trades = conn.execute('SELECT COUNT(*) FROM trades').fetchone()[0]
        
        results = []
        for offset in range(0, total_trades, batch_size):
            batch_df = pd.read_sql_query('''
                SELECT * FROM trades 
                LIMIT ? OFFSET ?
            ''', conn, params=(batch_size, offset))
            
            # Process batch
            batch_analysis = self.analyze_batch(batch_df)
            results.append(batch_analysis)
        
        conn.close()
        return self.combine_batch_results(results)
    
    # Use data sampling for quick insights
    def quick_sample_analysis(self, sample_size=50):
        """Analyze a representative sample for quick insights"""
        conn = sqlite3.connect(self.db_path)
        df = pd.read_sql_query('''
            SELECT * FROM trades 
            WHERE exit_price IS NOT NULL
            ORDER BY RANDOM() 
            LIMIT ?
        ''', conn, params=(sample_size,))
        conn.close()
        
        return self.analyze_performance_data(df)