add app

agents/__init__.py

@@ -0,0 +1,24 @@
+from .state import AgentState, AgentState2
+from .portfolio_analyzer import portfolio_analyzer
+from .news_analyzer import news_analyzer
+from .technical_analyzer import technical_analyzer, calculate_rsi
+from .recommendation_engine import recommendation_engine
+from .graph import setup_graph_with_tracking, setup_new_investments_graph
+from .rag_analyzer import rag_analyzer
+from .zacks_analyzer import zacks_analyzer
+from .new_investment_recommender import new_investment_recommender
+
+__all__ = [
+    'AgentState',
+    'AgentState2',
+    'portfolio_analyzer',
+    'news_analyzer',
+    'technical_analyzer',
+    'rag_analyzer',
+    'recommendation_engine',
+    'setup_graph_with_tracking',
+    'setup_new_investments_graph',
+    'zacks_analyzer',
+    'new_investment_recommender',
+    'calculate_rsi'
+] 

agents/graph.py

@@ -0,0 +1,118 @@
+from langgraph.graph import StateGraph, END
+from .state import AgentState, AgentState2
+from .portfolio_analyzer import portfolio_analyzer
+from .news_analyzer import news_analyzer
+from .technical_analyzer import technical_analyzer
+from .recommendation_engine import recommendation_engine
+from .rag_analyzer import rag_analyzer
+from .zacks_analyzer import zacks_analyzer
+from .new_investment_recommender import new_investment_recommender
+from .new_stock_analyzer import new_stock_analyzer
+from .portfolio_fit_evaluator import portfolio_fit_evaluator
+
+# def setup_graph():
+#     """Set up and compile the LangGraph workflow with a direct sequential flow.
+    
+#     The workflow follows a fixed sequence without a supervisor:
+#     PortfolioAnalyzer -> TechnicalAnalyzer -> NewsAnalyzer -> RAGAnalyzer -> RecommendationEngine -> END
+#     """
+#     # Define state schema
+#     workflow = StateGraph(AgentState)
+    
+#     # Add nodes
+#     workflow.add_node("PortfolioAnalyzer", portfolio_analyzer)
+#     workflow.add_node("NewsAnalyzer", news_analyzer)
+#     workflow.add_node("TechnicalAnalyzer", technical_analyzer)
+#     workflow.add_node("RAGAnalyzer", rag_analyzer)
+#     workflow.add_node("RecommendationEngine", recommendation_engine)
+    
+#     # Define direct sequential edges between agents
+#     workflow.add_edge("PortfolioAnalyzer", "TechnicalAnalyzer")
+#     workflow.add_edge("TechnicalAnalyzer", "NewsAnalyzer")
+#     workflow.add_edge("NewsAnalyzer", "RAGAnalyzer")
+#     workflow.add_edge("RAGAnalyzer", "RecommendationEngine")
+#     workflow.add_edge("RecommendationEngine", END)
+    
+#     # Set entry point
+#     workflow.set_entry_point("PortfolioAnalyzer")
+    
+#     return workflow.compile()
+
+def setup_graph_with_tracking(progress_callback=None):
+    """Set up and compile the LangGraph workflow with progress tracking and direct sequential flow.
+    
+    The workflow follows a fixed sequence without a supervisor:
+    TechnicalAnalyzer -> PortfolioAnalyzer -> NewsAnalyzer -> RAGAnalyzer -> RecommendationEngine -> END
+    """
+    # Define state schema
+    workflow = StateGraph(AgentState)
+    
+    # Add nodes with progress tracking wrappers if callback is provided
+    workflow.add_node("PortfolioAnalyzer", 
+                     lambda state: progress_callback(portfolio_analyzer(state)) if progress_callback else portfolio_analyzer(state))
+    
+    workflow.add_node("NewsAnalyzer", 
+                     lambda state: progress_callback(news_analyzer(state)) if progress_callback else news_analyzer(state))
+    
+    workflow.add_node("TechnicalAnalyzer", 
+                     lambda state: progress_callback(technical_analyzer(state)) if progress_callback else technical_analyzer(state))
+    
+    workflow.add_node("RAGAnalyzer", 
+                     lambda state: progress_callback(rag_analyzer(state)) if progress_callback else rag_analyzer(state))
+    
+    workflow.add_node("RecommendationEngine", 
+                     lambda state: progress_callback(recommendation_engine(state)) if progress_callback else recommendation_engine(state))
+    
+    # Define direct sequential edges between agents
+    workflow.add_edge("TechnicalAnalyzer", "PortfolioAnalyzer")
+    workflow.add_edge("PortfolioAnalyzer", "NewsAnalyzer")
+    workflow.add_edge("NewsAnalyzer", "RAGAnalyzer")
+    workflow.add_edge("RAGAnalyzer", "RecommendationEngine")
+    workflow.add_edge("RecommendationEngine", END)
+    
+    # Set entry point
+    workflow.set_entry_point("TechnicalAnalyzer")
+    
+    return workflow.compile() 
+
+def setup_new_investments_graph(progress_callback=None):
+    """Set up and compile a LangGraph workflow for finding new investment opportunities.
+    
+    The workflow follows a fixed sequence:
+    ZacksAnalyzer -> NewStockAnalyzer -> PortfolioFitEvaluator -> NewInvestmentRecommender -> END
+    
+    This workflow:
+    1. Fetches high-ranked stocks from Zacks
+    2. Performs technical analysis only on these new stocks
+    3. Evaluates how these new stocks fit into the existing portfolio
+    4. Recommends only stocks that have been properly analyzed
+    """
+    # Define state schema
+    workflow = StateGraph(AgentState2)
+    
+    # Add nodes with progress tracking wrappers if callback is provided
+    workflow.add_node("ZacksAnalyzer", 
+                     lambda state: progress_callback(zacks_analyzer(state)) if progress_callback else zacks_analyzer(state))
+    
+    # This node will analyze only the new high-ranked stocks, not the entire portfolio
+    workflow.add_node("NewStockAnalyzer", 
+                     lambda state: progress_callback(new_stock_analyzer(state)) if progress_callback else new_stock_analyzer(state))
+    
+    # This node evaluates how new stocks fit into the existing portfolio context
+    workflow.add_node("PortfolioFitEvaluator", 
+                     lambda state: progress_callback(portfolio_fit_evaluator(state)) if progress_callback else portfolio_fit_evaluator(state))
+    
+    # This node recommends only stocks that have been properly analyzed
+    workflow.add_node("NewInvestmentRecommender", 
+                     lambda state: progress_callback(new_investment_recommender(state)) if progress_callback else new_investment_recommender(state))
+    
+    # Define direct sequential edges between agents
+    workflow.add_edge("ZacksAnalyzer", "NewStockAnalyzer")
+    workflow.add_edge("NewStockAnalyzer", "PortfolioFitEvaluator")
+    workflow.add_edge("PortfolioFitEvaluator", "NewInvestmentRecommender")
+    workflow.add_edge("NewInvestmentRecommender", END)
+    
+    # Set entry point
+    workflow.set_entry_point("ZacksAnalyzer")
+    
+    return workflow.compile() 

agents/new_investment_recommender.py

@@ -0,0 +1,177 @@
+import os
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import ChatPromptTemplate
+from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser
+from typing import Dict, List
+from .state import AgentState
+
+def create_new_investment_recommender():
+    """Create a new investment recommender using LangChain."""
+    # Define the function schema for structured output
+    function_def = {
+        "name": "generate_new_investment_recommendations",
+        "description": "Generate new investment recommendations based on analyzed high-rank stocks and portfolio fit",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "new_investment_summary": {
+                    "type": "string",
+                    "description": "Summary of the new investment opportunities"
+                },
+                "new_investments": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "ticker": {
+                                "type": "string",
+                                "description": "Stock ticker symbol"
+                            },
+                            "action": {
+                                "type": "string",
+                                "enum": ["BUY"],
+                                "description": "Recommended action for this stock"
+                            },
+                            "reasoning": {
+                                "type": "string",
+                                "description": "Detailed reasoning for the recommendation"
+                            },
+                            "priority": {
+                                "type": "integer",
+                                "description": "Priority level (1-5, where 1 is highest priority)",
+                                "minimum": 1,
+                                "maximum": 5
+                            }
+                        },
+                        "required": ["ticker", "action", "reasoning", "priority"]
+                    }
+                }
+            },
+            "required": ["new_investment_summary", "new_investments"]
+        }
+    }
+    
+    # Create the prompt template
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", """You are an expert financial advisor specializing in identifying new investment opportunities.
+        
+Your task is to recommend only high-ranked stocks that have been properly analyzed and evaluated for portfolio fit.
+
+Consider the following when making recommendations:
+1. Technical analysis signals (RSI, moving averages, etc.)
+2. Fundamental analysis metrics (PE ratios, debt-to-equity, growth rates, etc.)
+3. Prioritize stocks that have been evaluated as good fits for the portfolio
+4. Consider the user's risk tolerance and investment goals
+5. Focus on stocks that complement the existing portfolio and improve diversification
+
+Provide clear, actionable recommendations with detailed reasoning.
+         
+IMPORTANT: For the reasoning of each recommendation, include a more detailed technical and fundamental analysis section:
+    - For technical analysis: Include specific insights about RSI levels, MACD signals, moving average crossovers, and what these indicators suggest about momentum and trend direction.
+    - For fundamental analysis: Include specific metrics like P/E ratio compared to industry average, debt-to-equity ratio, earnings growth, and what these metrics suggest about the company's valuation and financial health.
+         
+
+"""),
+        ("human", """
+I need recommendations for new investments based on the following information:
+
+User's Portfolio:
+{portfolio_data}
+
+User's Risk Tolerance: {risk_level}
+User's Investment Goals: {investment_goals}
+
+High-Ranked Stocks:
+{high_rank_stocks}
+
+New Stock Analysis:
+{new_stock_analysis}
+
+Portfolio Fit Evaluation:
+{portfolio_fit}
+
+Please provide specific recommendations for new investments that would complement my existing portfolio.
+Only recommend stocks that have been properly analyzed and evaluated for portfolio fit.
+""")
+    ])
+    
+    # Create the LLM
+    llm = ChatOpenAI(model="gpt-4-turbo", temperature=0.5, api_key=os.getenv("OPENAI_API_KEY"))
+    
+    # Create the structured output chain
+    chain = prompt | llm.bind_functions(functions=[function_def], function_call={"name": "generate_new_investment_recommendations"}) | JsonOutputFunctionsParser()
+    
+    return chain
+
+def new_investment_recommender(state: AgentState) -> AgentState:
+    """Recommends new investments based on analyzed high-rank stocks and portfolio fit evaluation."""
+    try:
+        # Get the portfolio data
+        portfolio = state["portfolio_data"]
+        
+        # Get the high-rank stocks
+        high_rank_stocks = state.get("high_rank_stocks", [])
+        
+        # Get the new stock analysis
+        new_stock_analysis = state.get("new_stock_analysis", {})
+        
+        # Get the portfolio fit evaluation
+        portfolio_fit = state.get("portfolio_fit", {})
+        
+        # If no stocks have been analyzed or evaluated, return early
+        if not new_stock_analysis or not portfolio_fit.get("evaluated_stocks"):
+            state["messages"] = state.get("messages", []) + [{
+                "role": "ai",
+                "content": "[NewInvestmentRecommender] No properly analyzed stocks to recommend."
+            }]
+            state["new_investment_summary"] = "No properly analyzed stocks to recommend."
+            state["new_investments"] = []
+            return state
+        
+        # Get user preferences
+        risk_level = state.get("risk_level", 5)
+        investment_goals = state.get("investment_goals", "Growth")
+        
+        # Create the recommender
+        recommender = create_new_investment_recommender()
+        
+        # Generate recommendations
+        result = recommender.invoke({
+            "portfolio_data": portfolio,
+            "risk_level": risk_level,
+            "investment_goals": investment_goals,
+            "high_rank_stocks": high_rank_stocks,
+            "new_stock_analysis": new_stock_analysis,
+            "portfolio_fit": portfolio_fit
+        })
+        
+        # Ensure we have the required fields
+        if "new_investment_summary" not in result:
+            result["new_investment_summary"] = f"Analysis of {len(high_rank_stocks)} high-ranked stocks."
+        
+        if "new_investments" not in result:
+            result["new_investments"] = []
+            
+    except Exception as e:
+        # Handle any errors in the recommendation engine
+        state["messages"] = state.get("messages", []) + [{
+            "role": "ai",
+            "content": f"[NewInvestmentRecommender] Error generating recommendations: {str(e)}"
+        }]
+        
+        result = {
+            "new_investment_summary": "Error in analysis",
+            "new_investments": []
+        }
+    
+    # Update state with recommendations
+    state["new_investment_summary"] = result.get("new_investment_summary", "")
+    state["new_investments"] = result.get("new_investments", [])
+    
+    # Add message to communication
+    state["messages"] = state.get("messages", []) + [{
+        "role": "ai",
+        "content": f"[NewInvestmentRecommender] I've analyzed the properly evaluated stocks and generated {len(result.get('new_investments', []))} recommendations for new investments."
+    }]
+    
+    return state 

agents/new_stock_analyzer.py

@@ -0,0 +1,160 @@
+import yfinance as yf
+import numpy as np
+import pandas as pd
+from typing import Dict, Any, List
+from .state import AgentState
+
+def calculate_rsi(prices, period=14):
+    """Calculate Relative Strength Index."""
+    # Calculate price changes
+    delta = prices.diff()
+    
+    # Separate gains and losses
+    gain = delta.clip(lower=0)
+    loss = -delta.clip(upper=0)
+    
+    # Calculate average gain and loss
+    avg_gain = gain.rolling(window=period).mean()
+    avg_loss = loss.rolling(window=period).mean()
+    
+    # Calculate relative strength (RS)
+    rs = avg_gain / avg_loss
+    
+    # Calculate RSI
+    rsi = 100 - (100 / (1 + rs))
+    
+    return rsi
+
+def calculate_macd(prices, fast=12, slow=26, signal=9):
+    """Calculate Moving Average Convergence Divergence."""
+    # Calculate EMAs
+    ema_fast = prices.ewm(span=fast, adjust=False).mean()
+    ema_slow = prices.ewm(span=slow, adjust=False).mean()
+    
+    # Calculate MACD line
+    macd_line = ema_fast - ema_slow
+    
+    # Calculate signal line
+    signal_line = macd_line.ewm(span=signal, adjust=False).mean()
+    
+    # Calculate histogram
+    histogram = macd_line - signal_line
+    
+    return {
+        'macd_line': macd_line,
+        'signal_line': signal_line,
+        'histogram': histogram
+    }
+
+def get_technical_indicators(ticker_obj, hist):
+    """Calculate technical indicators for a stock without making judgments."""
+    if hist.empty:
+        return None
+    
+    # Calculate basic technical indicators
+    hist['MA20'] = hist['Close'].rolling(window=20).mean()
+    hist['MA50'] = hist['Close'].rolling(window=50).mean()
+    hist['MA200'] = hist['Close'].rolling(window=200).mean()
+    hist['RSI'] = calculate_rsi(hist['Close'])
+    
+    # Calculate MACD
+    macd = calculate_macd(hist['Close'])
+    hist['MACD_Line'] = macd['macd_line']
+    hist['MACD_Signal'] = macd['signal_line']
+    hist['MACD_Histogram'] = macd['histogram']
+    
+    # Calculate Bollinger Bands
+    hist['BB_Middle'] = hist['Close'].rolling(window=20).mean()
+    std = hist['Close'].rolling(window=20).std()
+    hist['BB_Upper'] = hist['BB_Middle'] + (std * 2)
+    hist['BB_Lower'] = hist['BB_Middle'] - (std * 2)
+    
+    # Get latest values
+    latest = hist.iloc[-1]
+    
+    # Get fundamental data
+    info = ticker_obj.info
+    
+    return {
+        'current_price': latest['Close'],
+        'technical_indicators': {
+            'ma20': latest['MA20'],
+            'ma50': latest['MA50'],
+            'ma200': latest['MA200'],
+            'rsi': latest['RSI'],
+            'macd_line': latest['MACD_Line'],
+            'macd_signal': latest['MACD_Signal'],
+            'macd_histogram': latest['MACD_Histogram'],
+            'bb_upper': latest['BB_Upper'],
+            'bb_middle': latest['BB_Middle'],
+            'bb_lower': latest['BB_Lower'],
+            'volume': latest['Volume']
+        },
+        'fundamental_data': {
+            'symbol': ticker_obj.ticker,
+            'price': info.get('currentPrice'),
+            'pe_ratio': info.get('trailingPE'),
+            'peg_ratio': info.get('pegRatio'),
+            'debt_to_equity': info.get('debtToEquity'),
+            'forward_pe': info.get('forwardPE'),
+            'beta': info.get('beta'),
+            'return_on_equity': info.get('returnOnEquity'),
+            'free_cash_flow': info.get('freeCashflow'),
+            'revenue_growth': info.get('revenueGrowth'),
+            'earnings_growth': info.get('earningsGrowth'),
+            'dividend_yield': info.get('dividendYield'),
+            'market_cap': info.get('marketCap'),
+            'profit_margins': info.get('profitMargins'),
+            'price_to_book': info.get('priceToBook')
+        }
+    }
+
+def new_stock_analyzer(state: AgentState) -> AgentState:
+    """Performs technical analysis only on the new high-ranked stocks from Zacks."""
+    # Get the high-rank stocks from the Zacks analyzer
+    high_rank_stocks = state.get("high_rank_stocks", [])
+    
+    if not high_rank_stocks:
+        state["messages"] = state.get("messages", []) + [{
+            "role": "ai",
+            "content": "[NewStockAnalyzer] No high-ranked stocks found to analyze."
+        }]
+        state["new_stock_analysis"] = {}
+        return state
+    
+    # Extract tickers from high-rank stocks
+    tickers = [stock['symbol'] for stock in high_rank_stocks]
+    analysis_results = {}
+    
+    # Collect technical data for all new stocks
+    for ticker in tickers:
+        try:
+            # Get stock data
+            stock = yf.Ticker(ticker)
+            hist = stock.history(period="6mo")
+            
+            if not hist.empty:
+                # Get comprehensive technical indicators without judgments
+                indicators = get_technical_indicators(stock, hist)
+                
+                if indicators:
+                    analysis_results[ticker] = indicators
+                else:
+                    analysis_results[ticker] = {"error": "Failed to calculate indicators"}
+            else:
+                analysis_results[ticker] = {"error": "No historical data available"}
+                
+        except Exception as e:
+            print(f"Error analyzing {ticker}: {str(e)}")
+            analysis_results[ticker] = {"error": str(e)}
+    
+    # Update state with new stock analysis
+    state["new_stock_analysis"] = analysis_results
+    
+    # Add message to communication
+    state["messages"] = state.get("messages", []) + [{
+        "role": "ai",
+        "content": f"[NewStockAnalyzer] I've calculated technical indicators and gathered fundamental data for {len(analysis_results)} new high-ranked stocks."
+    }]
+    
+    return state 

agents/news_analyzer.py

@@ -0,0 +1,274 @@
+import os
+import datetime
+from newsapi import NewsApiClient
+from typing import List, Dict, Any
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import ChatPromptTemplate
+from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser
+from .state import AgentState
+
+def fetch_news(tickers, days=7):
+    """Fetch news for the given tickers from NewsAPI."""
+    # You need to set NEWSAPI_KEY in your .env file
+    newsapi_key = os.getenv("NEWSAPI_KEY")
+    if not newsapi_key:
+        print("NewsAPI key not found. Please add NEWSAPI_KEY to your .env file.")
+        return []
+    
+    newsapi = NewsApiClient(api_key=newsapi_key)
+    news_items = []
+    
+    # Get current date and date from n days ago
+    today = datetime.datetime.now().strftime('%Y-%m-%d')
+    days_ago = (datetime.datetime.now() - datetime.timedelta(days=days)).strftime('%Y-%m-%d')
+    
+    for ticker in tickers:
+        try:
+            # Search for news about the ticker
+            all_articles = newsapi.get_everything(
+                q=ticker,
+                from_param=days_ago,
+                to=today,
+                language='en',
+                sort_by='relevancy',
+                page_size=3  # Get top 3 news items per ticker
+            )
+            
+            # Process the articles
+            if all_articles['status'] == 'ok' and all_articles['totalResults'] > 0:
+                for article in all_articles['articles']:
+                    news_items.append({
+                        'ticker': ticker,
+                        'title': article['title'],
+                        'summary': article['description'] or "No description available.",
+                        'url': article['url'],
+                        'urlToImage': article['urlToImage'],
+                        'published_at': article['publishedAt'],
+                        'content': article.get('content', '')
+                    })
+            
+            # If no news found, add a placeholder
+            if not all_articles['articles']:
+                news_items.append({
+                    'ticker': ticker,
+                    'title': f"No recent news found for {ticker}",
+                    'summary': "No relevant news articles were found for this ticker in the past week.",
+                    'url': "",
+                    'urlToImage': "",
+                    'published_at': today,
+                    'content': ""
+                })
+                
+        except Exception as e:
+            # Handle API errors or other exceptions
+            print(f"Error fetching news for {ticker}: {str(e)}")
+            news_items.append({
+                'ticker': ticker,
+                'title': f"Error fetching news for {ticker}",
+                'summary': f"Could not retrieve news due to an error: {str(e)}",
+                'url': "",
+                'urlToImage': "",
+                'published_at': today,
+                'content': ""
+            })
+    
+    return news_items
+
+def create_news_analyzer_chain():
+    """Create a chain for news analysis using LLM."""
+    # Define function for structured output
+    function_def = {
+        "name": "analyze_news",
+        "description": "Analyze financial news articles for sentiment and impact",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "articles": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "ticker": {
+                                "type": "string",
+                                "description": "Stock ticker symbol"
+                            },
+                            "title": {
+                                "type": "string",
+                                "description": "News article title"
+                            },
+                            "summary": {
+                                "type": "string",
+                                "description": "Summary of the news article"
+                            },
+                            "url": {
+                                "type": "string",
+                                "description": "URL of the news article"
+                            },
+                            "urlToImage": {
+                                "type": "string",
+                                "description": "URL of image from the news article"
+                            },
+                            "published_at": {
+                                "type": "string",
+                                "description": "Publication date of the article"
+                            },
+                            "sentiment": {
+                                "type": "string",
+                                "enum": ["positive", "negative", "neutral"],
+                                "description": "Sentiment of the article towards the stock"
+                            },
+                            "impact_analysis": {
+                                "type": "string",
+                                "description": "Analysis of how this news might impact the stock"
+                            },
+                            "key_points": {
+                                "type": "array",
+                                "items": {
+                                    "type": "string"
+                                },
+                                "description": "Key points extracted from the news article"
+                            },
+                            "market_implications": {
+                                "type": "string",
+                                "description": "Broader market implications of this news"
+                            }
+                        },
+                        "required": ["ticker", "title", "summary", "sentiment", "impact_analysis", "url", "urlToImage"]
+                    }
+                },
+                "overall_market_sentiment": {
+                    "type": "string",
+                    "description": "Overall market sentiment based on all news articles"
+                },
+                "key_trends": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "description": "Key trends identified across all news articles"
+                }
+            },
+            "required": ["articles", "overall_market_sentiment"]
+        }
+    }
+    
+    # Create prompt template
+    prompt = ChatPromptTemplate.from_template("""
+    You are a financial news analyst. Analyze the following news articles about stocks.
+    
+    For each article, determine the sentiment (positive, negative, or neutral) and provide a brief analysis of how this news might impact the stock.
+    Focus on the news content itself and its potential market implications.
+    
+    IMPORTANT: Only include articles that are directly relevant to the stocks in the portfolio or to financial markets in general.
+    Exclude any articles that are not related to financial markets, stocks, or investing.
+    
+    NEWS ARTICLES:
+    {news_articles}
+    
+    PORTFOLIO CONTEXT:
+    {portfolio_context}
+    
+    Provide a detailed sentiment analysis for each article and an overall market sentiment assessment.
+    Focus on the news content and market implications rather than current portfolio performance.
+    """)
+
+    #CRITICAL: For each article, you MUST include the URL exactly as provided in the input. Do not modify or omit the URL.
+    
+    # Create LLM
+    llm = ChatOpenAI(model="gpt-4-turbo", temperature=0.2)
+    
+    # Create chain
+    chain = (
+        prompt 
+        | llm.bind_functions(functions=[function_def], function_call="analyze_news")
+        | JsonOutputFunctionsParser()
+    )
+    
+    return chain
+
+# Initialize news analyzer chain
+news_analyzer_chain = create_news_analyzer_chain()
+
+def news_analyzer(state: AgentState) -> AgentState:
+    """Gathers and analyzes news for relevant assets using NewsAPI and LLM."""
+    portfolio = state["portfolio_data"]
+    tickers = list(portfolio.keys())
+    
+    try:
+        # Fetch news
+        news_items = fetch_news(tickers)
+        
+        if not news_items:
+            # If no news found, return empty analysis
+            state["news_analysis"] = []
+            state["messages"] = state.get("messages", []) + [{
+                "role": "ai",
+                "content": "[NewsAnalyzer] I couldn't find any relevant news for your portfolio stocks."
+            }]
+            return state
+        
+        # Format portfolio context - simplified to focus on tickers only
+        portfolio_context = "Portfolio contains the following tickers:\n"
+        for ticker in tickers:
+            portfolio_context += f"{ticker}\n"
+        
+        # Format news articles for LLM
+        news_articles_str = ""
+        for item in news_items:
+            news_articles_str += f"TICKER: {item['ticker']}\n"
+            news_articles_str += f"TITLE: {item['title']}\n"
+            news_articles_str += f"SUMMARY: {item['summary']}\n"
+            news_articles_str += f"URL: {item['url']}\n"
+            news_articles_str += f"URLTOIMAGE: {item['urlToImage']}\n"
+            news_articles_str += f"PUBLISHED: {item['published_at']}\n"
+            if item['content']:
+                news_articles_str += f"CONTENT: {item['content']}\n"
+            news_articles_str += "\n---\n\n"
+        
+        # Analyze news with LLM
+        try:
+            result = news_analyzer_chain.invoke({
+                "news_articles": news_articles_str,
+                "portfolio_context": portfolio_context
+            })
+            
+            # Update state with analyzed news
+            state["news_analysis"] = result["articles"]
+            
+            # Add message to communication
+            state["messages"] = state.get("messages", []) + [{
+                "role": "ai",
+                "content": f"[NewsAnalyzer] I've analyzed recent news for your portfolio stocks. Overall market sentiment: {result['overall_market_sentiment']}"
+            }]
+        except Exception as e:
+            print(f"Error analyzing news with LLM: {str(e)}")
+            # Create a default analysis if LLM fails
+            default_analysis = []
+            for item in news_items[:5]:  # Process up to 5 news items
+                default_analysis.append({
+                    "ticker": item["ticker"],
+                    "title": item["title"],
+                    "summary": item["summary"],
+                    "url": item["url"],
+                    "urlToImage": item["urlToImage"],
+                    "published_at": item.get("published_at", ""),
+                    "sentiment": "neutral",
+                    "impact_analysis": "Could not analyze impact due to processing error.",
+                    "key_points": ["News content could not be analyzed"],
+                    "market_implications": "Unknown due to processing limitations"
+                })
+            
+            state["news_analysis"] = default_analysis
+            state["messages"] = state.get("messages", []) + [{
+                "role": "ai",
+                "content": "[NewsAnalyzer] I found some news for your portfolio stocks, but couldn't perform detailed analysis."
+            }]
+    except Exception as e:
+        print(f"Error in news analyzer: {str(e)}")
+        state["news_analysis"] = []
+        state["messages"] = state.get("messages", []) + [{
+            "role": "ai",
+            "content": f"[NewsAnalyzer] I encountered an error while analyzing news: {str(e)}"
+        }]
+    
+    return state

agents/portfolio_analyzer.py

@@ -0,0 +1,168 @@
+import yfinance as yf
+import numpy as np
+from typing import Dict, Any
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import ChatPromptTemplate
+from langchain.schema import StrOutputParser
+from .state import AgentState
+import os
+
+from dotenv import load_dotenv
+load_dotenv()
+
+def get_portfolio_data(portfolio):
+    """Fetch historical data for portfolio assets."""
+    tickers = list(portfolio.keys())
+    
+    # Get historical data for portfolio assets
+    historical_data = {}
+    
+    for ticker in tickers:
+        try:
+            ticker_obj = yf.Ticker(ticker)
+            data = ticker_obj.history(period="1y")
+            historical_data[ticker] = data
+        except Exception as e:
+            print(f"Error fetching data for {ticker}: {e}")
+            
+    return historical_data
+
+def calculate_portfolio_metrics(portfolio, historical_data):
+    """Calculate portfolio metrics."""
+    # Calculate portfolio metrics
+    total_value = sum(portfolio[ticker]["value"] for ticker in portfolio)
+    allocations = {ticker: portfolio[ticker]["value"] / total_value for ticker in portfolio}
+    
+    # Calculate volatility and returns
+    returns = {}
+    volatility = {}
+    for ticker in historical_data:
+        if not historical_data[ticker].empty:
+            price_data = historical_data[ticker]['Close']
+            daily_returns = price_data.pct_change().dropna()
+            returns[ticker] = daily_returns.mean() * 252  # Annualized return
+            volatility[ticker] = daily_returns.std() * np.sqrt(252)  # Annualized volatility
+    
+    return {
+        "total_value": total_value,
+        "allocations": allocations,
+        "returns": returns,
+        "volatility": volatility
+    }
+
+def create_portfolio_analyzer_chain():
+    """Create a chain for portfolio analysis using LLM."""
+    # Define prompt template
+    prompt = ChatPromptTemplate.from_template("""
+    You are a portfolio analysis expert. Analyze the following portfolio information and provide insights.
+    
+    Portfolio Data:
+    {portfolio_data}
+    
+    Portfolio Metrics:
+    {portfolio_metrics}
+    
+    Fundamental Data:
+    {fundamental_data}
+    
+    Risk Level: {risk_level}
+    Investment Goals: {investment_goals}
+    
+    Provide a comprehensive analysis of the portfolio including:
+    1. Overall portfolio composition and diversification
+    2. Risk assessment based on volatility and beta
+    3. Valuation assessment based on fundamental metrics
+    4. Alignment with the user's risk level and investment goals
+    5. Areas of concern or potential improvement
+    
+    Your analysis should be detailed, insightful, and actionable.
+    """)
+    openai_api_key = os.getenv("OPENAI_API_KEY")
+    # Create LLM
+    llm = ChatOpenAI(model="gpt-4-turbo", temperature=0.2, api_key=openai_api_key)
+    
+    # Create chain
+    chain = prompt | llm | StrOutputParser()
+    
+    return chain
+
+# Initialize portfolio analyzer chain
+portfolio_analyzer_chain = create_portfolio_analyzer_chain()
+
+def portfolio_analyzer(state: AgentState) -> AgentState:
+    """Analyzes the current portfolio composition using LLM."""
+    portfolio = state["portfolio_data"]
+    risk_level = state["risk_level"]
+    investment_goals = state["investment_goals"]
+    
+    # Get portfolio data
+    historical_data = get_portfolio_data(portfolio)
+    
+    # Calculate portfolio metrics
+    portfolio_metrics = calculate_portfolio_metrics(portfolio, historical_data)
+    
+    # Format data for LLM
+    portfolio_data_str = ""
+    for ticker, data in portfolio.items():
+        portfolio_data_str += f"{ticker}: {data['shares']} shares at ${data['purchase_price']:.2f}, "
+        portfolio_data_str += f"current value: ${data['value']:.2f}, "
+        portfolio_data_str += f"gain/loss: {data['gain_loss_pct']:.2f}%\n"
+    
+    # Get fundamental data from technical analysis if available
+    fundamental_data = {}
+    if "technical_analysis" in state:
+        for ticker, analysis in state["technical_analysis"].items():
+            if "fundamental_data" in analysis:
+                fundamental_data[ticker] = analysis["fundamental_data"]
+    
+    # Format fundamental data for LLM
+    fundamental_data_str = ""
+    for ticker, data in fundamental_data.items():
+        fundamental_data_str += f"{ticker}:\n"
+        for key, value in data.items():
+            if value is not None:
+                fundamental_data_str += f"  {key}: {value}\n"
+        fundamental_data_str += "\n"
+    
+    # Format portfolio metrics for LLM
+    portfolio_metrics_str = ""
+    portfolio_metrics_str += f"Total Value: ${portfolio_metrics['total_value']:.2f}\n\n"
+    
+    portfolio_metrics_str += "Allocations:\n"
+    for ticker, allocation in portfolio_metrics['allocations'].items():
+        portfolio_metrics_str += f"  {ticker}: {allocation*100:.2f}%\n"
+    
+    portfolio_metrics_str += "\nAnnualized Returns:\n"
+    for ticker, ret in portfolio_metrics['returns'].items():
+        portfolio_metrics_str += f"  {ticker}: {ret*100:.2f}%\n"
+    
+    portfolio_metrics_str += "\nAnnualized Volatility:\n"
+    for ticker, vol in portfolio_metrics['volatility'].items():
+        portfolio_metrics_str += f"  {ticker}: {vol*100:.2f}%\n"
+    
+    # Get LLM analysis
+    analysis = portfolio_analyzer_chain.invoke({
+        "portfolio_data": portfolio_data_str,
+        "portfolio_metrics": portfolio_metrics_str,
+        "fundamental_data": fundamental_data_str,
+        "risk_level": risk_level,
+        "investment_goals": investment_goals
+    })
+    
+    # Update state
+    state["portfolio_analysis"] = {
+        "total_value": portfolio_metrics["total_value"],
+        "allocations": portfolio_metrics["allocations"],
+        "returns": portfolio_metrics["returns"],
+        "volatility": portfolio_metrics["volatility"],
+        "fundamental_data": fundamental_data,
+        "llm_analysis": analysis
+    }
+    
+    # Add message to communication
+    state["messages"] = state.get("messages", []) + [{
+        "role": "ai",
+        "content": f"[PortfolioAnalyzer] I've analyzed your portfolio. Here are my findings:\n\n{analysis}"
+    }]
+    
+    return state

agents/portfolio_fit_evaluator.py

@@ -0,0 +1,173 @@
+import os
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import ChatPromptTemplate
+from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser
+from typing import Dict, List
+from .state import AgentState
+
+def create_portfolio_fit_evaluator():
+    """Create a portfolio fit evaluator using LangChain."""
+    # Define the function schema for structured output
+    function_def = {
+        "name": "evaluate_portfolio_fit",
+        "description": "Evaluate how new stocks fit into the existing portfolio",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "portfolio_fit_summary": {
+                    "type": "string",
+                    "description": "Summary of how the new stocks fit into the existing portfolio"
+                },
+                "evaluated_stocks": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "ticker": {
+                                "type": "string",
+                                "description": "Stock ticker symbol"
+                            },
+                            "portfolio_fit_score": {
+                                "type": "integer",
+                                "description": "Score from 1-10 indicating how well the stock fits in the portfolio (10 being best)",
+                                "minimum": 1,
+                                "maximum": 10
+                            },
+                            "diversification_impact": {
+                                "type": "string",
+                                "description": "How this stock would impact portfolio diversification"
+                            },
+                            "risk_impact": {
+                                "type": "string",
+                                "description": "How this stock would impact portfolio risk"
+                            },
+                            "sector_balance": {
+                                "type": "string",
+                                "description": "How this stock would affect sector balance in the portfolio"
+                            },
+                            "recommendation": {
+                                "type": "string",
+                                "enum": ["STRONG_FIT", "MODERATE_FIT", "POOR_FIT"],
+                                "description": "Overall recommendation for portfolio fit"
+                            }
+                        },
+                        "required": ["ticker", "portfolio_fit_score", "diversification_impact", "risk_impact", "sector_balance", "recommendation"]
+                    }
+                }
+            },
+            "required": ["portfolio_fit_summary", "evaluated_stocks"]
+        }
+    }
+    
+    # Create the prompt template
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", """You are an expert portfolio manager specializing in evaluating how new investments fit into existing portfolios.
+        
+Your task is to analyze new high-ranked stocks and evaluate how well they would fit into the user's existing portfolio.
+
+Consider the following when evaluating portfolio fit:
+1. Diversification across sectors, industries, and asset classes
+2. Risk profile and how it aligns with the user's risk tolerance
+3. Correlation with existing holdings
+4. Impact on overall portfolio performance
+5. Balance between growth and value investments
+6. Geographic diversification if applicable
+
+Provide a detailed evaluation of each stock's fit within the portfolio context.
+"""),
+        ("human", """
+I need to evaluate how these new high-ranked stocks would fit into my existing portfolio:
+
+User's Portfolio:
+{portfolio_data}
+
+User's Risk Tolerance: {risk_level}
+User's Investment Goals: {investment_goals}
+
+Technical Analysis of Existing Portfolio:
+{technical_analysis}
+
+New High-Ranked Stocks Analysis:
+{new_stock_analysis}
+
+Please evaluate how each new stock would fit into my existing portfolio.
+""")
+    ])
+    
+    # Create the LLM
+    llm = ChatOpenAI(model="gpt-4-turbo", temperature=0.2, api_key=os.getenv("OPENAI_API_KEY"))
+    
+    # Create the structured output chain
+    chain = prompt | llm.bind_functions(functions=[function_def], function_call={"name": "evaluate_portfolio_fit"}) | JsonOutputFunctionsParser()
+    
+    return chain
+
+def portfolio_fit_evaluator(state: AgentState) -> AgentState:
+    """Evaluates how new high-ranked stocks fit into the existing portfolio context."""
+    try:
+        # Get the portfolio data
+        portfolio = state["portfolio_data"]
+        
+        # Get the technical analysis of the existing portfolio
+        technical_analysis = state.get("technical_analysis", {})
+        
+        # Get the analysis of new stocks
+        new_stock_analysis = state.get("new_stock_analysis", {})
+        
+        # If no new stocks to evaluate, return early
+        if not new_stock_analysis:
+            state["messages"] = state.get("messages", []) + [{
+                "role": "ai",
+                "content": "[PortfolioFitEvaluator] No new stocks to evaluate for portfolio fit."
+            }]
+            state["portfolio_fit"] = {
+                "portfolio_fit_summary": "No new stocks to evaluate.",
+                "evaluated_stocks": []
+            }
+            return state
+        
+        # Get user preferences
+        risk_level = state.get("risk_level", 5)
+        investment_goals = state.get("investment_goals", "Growth")
+        
+        # Create the evaluator
+        evaluator = create_portfolio_fit_evaluator()
+        
+        # Generate evaluation
+        result = evaluator.invoke({
+            "portfolio_data": portfolio,
+            "risk_level": risk_level,
+            "investment_goals": investment_goals,
+            "technical_analysis": technical_analysis,
+            "new_stock_analysis": new_stock_analysis
+        })
+        
+        # Ensure we have the required fields
+        if "portfolio_fit_summary" not in result:
+            result["portfolio_fit_summary"] = f"Evaluation of {len(new_stock_analysis)} new stocks for portfolio fit."
+        
+        if "evaluated_stocks" not in result:
+            result["evaluated_stocks"] = []
+            
+    except Exception as e:
+        # Handle any errors in the evaluation
+        state["messages"] = state.get("messages", []) + [{
+            "role": "ai",
+            "content": f"[PortfolioFitEvaluator] Error evaluating portfolio fit: {str(e)}"
+        }]
+        
+        result = {
+            "portfolio_fit_summary": "Error in evaluation",
+            "evaluated_stocks": []
+        }
+    
+    # Update state with portfolio fit evaluation
+    state["portfolio_fit"] = result
+    
+    # Add message to communication
+    state["messages"] = state.get("messages", []) + [{
+        "role": "ai",
+        "content": f"[PortfolioFitEvaluator] I've evaluated how {len(result.get('evaluated_stocks', []))} new stocks would fit into your existing portfolio."
+    }]
+    
+    return state 

agents/rag_analyzer.py

@@ -0,0 +1,309 @@
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import ChatPromptTemplate
+from langchain.schema import StrOutputParser
+from operator import itemgetter
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain_community.vectorstores import Chroma
+from .state import AgentState
+import os
+
+# Initialize embedding model
+embeddings = HuggingFaceEmbeddings(model_name="Snowflake/snowflake-arctic-embed-l")
+
+# Initialize Vector DB
+vector_db = Chroma(embedding_function=embeddings, persist_directory="./chroma_db")
+
+# Define RAG prompt template for technical analysis interpretation
+TECHNICAL_RAG_PROMPT = """
+CONTEXT:
+{context}
+
+TECHNICAL INDICATORS:
+{technical_data}
+
+USER PORTFOLIO INFORMATION:
+Risk Level: {risk_level}
+Investment Goals: {investment_goals}
+
+You are a financial advisor with expertise in both technical and fundamental analysis. Use the available context from "Security Analysis" by Graham and Dodd along with the technical indicators to provide insights on the stock.
+
+For each stock, analyze:
+1. What the technical indicators suggest about current market sentiment and potential price movements
+2. How the fundamental data aligns with value investing principles
+3. Whether the stock appears to be undervalued, fairly valued, or overvalued
+4. How this stock fits within the user's risk profile and investment goals
+
+Provide a balanced analysis that considers both technical signals and fundamental principles.
+"""
+
+technical_rag_prompt = ChatPromptTemplate.from_template(TECHNICAL_RAG_PROMPT)
+
+# Define RAG prompt template for portfolio insights
+PORTFOLIO_RAG_PROMPT = """
+CONTEXT:
+{context}
+
+USER PORTFOLIO INFORMATION:
+Risk Level: {risk_level}
+Investment Goals: {investment_goals}
+Portfolio: {portfolio}
+
+You are a financial advisor with expertise in fundamental analysis. Use the available context from "Security Analysis" by Graham and Dodd to provide insights on the user's portfolio and investment strategy.
+Focus on applying fundamental analysis principles to the user's specific situation.
+
+Answer the following questions:
+1. What would Graham and Dodd recommend for this investor with their risk level and goals?
+2. What fundamental analysis principles should be applied to this portfolio?
+3. How should this investor think about value investing in today's market?
+
+Provide your answers in a clear, concise format.
+"""
+
+portfolio_rag_prompt = ChatPromptTemplate.from_template(PORTFOLIO_RAG_PROMPT)
+
+# Define a batch analysis prompt for multiple stocks
+BATCH_ANALYSIS_PROMPT = """
+CONTEXT:
+{context}
+
+USER PORTFOLIO INFORMATION:
+Risk Level: {risk_level}
+Investment Goals: {investment_goals}
+
+STOCKS TO ANALYZE:
+{stocks_data}
+
+You are a financial advisor with expertise in both technical and fundamental analysis. Use the available context from "Security Analysis" by Graham and Dodd along with the technical indicators to provide insights on each stock.
+
+For each stock, provide a brief analysis that includes:
+1. What the technical indicators suggest about current market sentiment
+2. Whether the stock appears to be undervalued, fairly valued, or overvalued
+3. How this stock fits within the user's risk profile and investment goals
+
+Format your response as a JSON-like structure with ticker symbols as keys and analysis as values.
+"""
+
+batch_analysis_prompt = ChatPromptTemplate.from_template(BATCH_ANALYSIS_PROMPT)
+
+def setup_technical_rag_chain():
+    """Set up the RAG chain for technical analysis interpretation."""
+    # Initialize LLM - using a faster model for individual stock analysis
+    llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.2)
+    
+    # Create retriever
+    retriever = vector_db.as_retriever(search_kwargs={"k": 3})
+    
+    # Create RAG chain for technical analysis
+    technical_rag_chain = (
+        {
+            "context": lambda x: retriever.invoke("technical analysis indicators interpretation value investing"), 
+            "technical_data": itemgetter("technical_data"),
+            "risk_level": itemgetter("risk_level"),
+            "investment_goals": itemgetter("investment_goals")
+        }
+        | technical_rag_prompt 
+        | llm 
+        | StrOutputParser()
+    )
+    
+    return technical_rag_chain
+
+def setup_portfolio_rag_chain():
+    """Set up the RAG chain for portfolio insights."""
+    # Initialize LLM - using GPT-4o-mini for better performance while maintaining quality
+    llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.2)
+    
+    # Create retriever
+    retriever = vector_db.as_retriever(search_kwargs={"k": 5})
+    
+    # Create RAG chain for portfolio insights
+    portfolio_rag_chain = (
+        {
+            "context": lambda x: retriever.invoke("value investing portfolio analysis Graham Dodd"), 
+            "risk_level": itemgetter("risk_level"),
+            "investment_goals": itemgetter("investment_goals"),
+            "portfolio": itemgetter("portfolio")
+        }
+        | portfolio_rag_prompt 
+        | llm 
+        | StrOutputParser()
+    )
+    
+    return portfolio_rag_chain
+
+def setup_batch_analysis_chain():
+    """Set up the RAG chain for batch stock analysis."""
+    # Initialize LLM - using GPT-4o-mini for better performance while maintaining quality
+    llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.2)
+    
+    # Create retriever
+    retriever = vector_db.as_retriever(search_kwargs={"k": 4})
+    
+    # Create RAG chain for batch analysis
+    batch_analysis_chain = (
+        {
+            "context": lambda x: retriever.invoke("technical analysis fundamental analysis value investing"), 
+            "stocks_data": itemgetter("stocks_data"),
+            "risk_level": itemgetter("risk_level"),
+            "investment_goals": itemgetter("investment_goals")
+        }
+        | batch_analysis_prompt 
+        | llm 
+        | StrOutputParser()
+    )
+    
+    return batch_analysis_chain
+
+# Initialize the RAG chains
+technical_rag_chain = setup_technical_rag_chain()
+portfolio_rag_chain = setup_portfolio_rag_chain()
+batch_analysis_chain = setup_batch_analysis_chain()
+
+def get_stock_interpretation(technical_data_str, risk_level, investment_goals):
+    """Get RAG-based interpretation for a stock's technical data."""
+    return technical_rag_chain.invoke({
+        "technical_data": technical_data_str,
+        "risk_level": risk_level,
+        "investment_goals": investment_goals
+    })
+
+def get_portfolio_insights(portfolio_str, risk_level, investment_goals):
+    """Get RAG-based insights for a portfolio."""
+    return portfolio_rag_chain.invoke({
+        "risk_level": risk_level,
+        "investment_goals": investment_goals,
+        "portfolio": portfolio_str
+    })
+
+def rag_analyzer(state: AgentState) -> AgentState:
+    """Performs RAG-based analysis on technical data and portfolio."""
+    portfolio = state["portfolio_data"]
+    risk_level = state["risk_level"]
+    investment_goals = state["investment_goals"]
+    technical_analysis = state.get("technical_analysis", {})
+    
+    # Format portfolio for RAG
+    portfolio_str = ""
+    for ticker, data in portfolio.items():
+        portfolio_str += f"{ticker}: {data['shares']} shares at ${data['purchase_price']:.2f}, "
+        portfolio_str += f"current value: ${data['value']:.2f}, "
+        portfolio_str += f"gain/loss: {data['gain_loss_pct']:.2f}%\n"
+    
+    # Generate portfolio-level insights using RAG (single call instead of multiple)
+    portfolio_insights_text = get_portfolio_insights(
+        portfolio_str, 
+        risk_level, 
+        investment_goals
+    )
+    
+    # Parse the portfolio insights into structured format
+    lines = portfolio_insights_text.strip().split('\n')
+    portfolio_insights = []
+    
+    # Extract questions and answers from the response
+    current_question = None
+    current_answer = []
+    
+    for line in lines:
+        if line.startswith('1.') or line.startswith('2.') or line.startswith('3.'):
+            # If we have a previous question, save it
+            if current_question is not None:
+                portfolio_insights.append({
+                    "question": current_question,
+                    "response": '\n'.join(current_answer).strip()
+                })
+                current_answer = []
+            
+            # Extract new question
+            parts = line.split(':', 1)
+            if len(parts) > 1:
+                current_question = parts[0].strip()
+                current_answer.append(parts[1].strip())
+            else:
+                current_question = line.strip()
+        elif current_question is not None:
+            current_answer.append(line)
+    
+    # Add the last question/answer if exists
+    if current_question is not None and current_answer:
+        portfolio_insights.append({
+            "question": current_question,
+            "response": '\n'.join(current_answer).strip()
+        })
+    
+    # If we couldn't parse properly, create a fallback structure
+    if not portfolio_insights:
+        portfolio_insights = [
+            {"question": "Portfolio Analysis", "response": portfolio_insights_text}
+        ]
+    
+    # Only process technical analysis if there are stocks to analyze
+    if technical_analysis:
+        # Prepare batch analysis data instead of individual calls
+        stocks_data = ""
+        for ticker, data in technical_analysis.items():
+            if "error" not in data:
+                stocks_data += f"Stock: {ticker}\n"
+                stocks_data += f"Current Price: ${data['current_price']:.2f}\n"
+                stocks_data += "Technical Indicators:\n"
+                for key, value in data['technical_indicators'].items():
+                    stocks_data += f"  {key}: {value}\n"
+                stocks_data += "Fundamental Data:\n"
+                for key, value in data['fundamental_data'].items():
+                    if value is not None:
+                        stocks_data += f"  {key}: {value}\n"
+                stocks_data += "\n---\n\n"
+        
+        # Only make the batch analysis call if we have stocks to analyze
+        if stocks_data:
+            try:
+                # Get batch analysis for all stocks in one call
+                batch_analysis_result = batch_analysis_chain.invoke({
+                    "stocks_data": stocks_data,
+                    "risk_level": risk_level,
+                    "investment_goals": investment_goals
+                })
+                
+                # Parse the batch results and update technical_analysis
+                # This is a simplified parsing - in production you might want more robust parsing
+                current_ticker = None
+                current_analysis = []
+                
+                for line in batch_analysis_result.split('\n'):
+                    if ':' in line and line.split(':')[0].strip() in technical_analysis:
+                        # If we have a previous ticker, save its analysis
+                        if current_ticker is not None and current_ticker in technical_analysis:
+                            technical_analysis[current_ticker]["rag_interpretation"] = '\n'.join(current_analysis).strip()
+                            current_analysis = []
+                        
+                        # Start new ticker
+                        current_ticker = line.split(':')[0].strip()
+                        current_analysis.append(line.split(':', 1)[1].strip())
+                    elif current_ticker is not None:
+                        current_analysis.append(line)
+                
+                # Add the last ticker's analysis
+                if current_ticker is not None and current_ticker in technical_analysis:
+                    technical_analysis[current_ticker]["rag_interpretation"] = '\n'.join(current_analysis).strip()
+            except Exception as e:
+                # Fallback to a simpler approach if batch processing fails
+                for ticker, data in technical_analysis.items():
+                    if "error" not in data:
+                        technical_analysis[ticker]["rag_interpretation"] = f"Analysis unavailable due to processing error: {str(e)}"
+    
+    # Combine portfolio insights
+    combined_insights = "\n\n".join([f"Q: {insight['question']}\nA: {insight['response']}" for insight in portfolio_insights])
+    
+    # Update state with RAG insights
+    state["technical_analysis"] = technical_analysis
+    state["rag_context"] = combined_insights
+    state["fundamental_analysis"] = state.get("fundamental_analysis", {})
+    state["fundamental_analysis"]["security_analysis_insights"] = portfolio_insights
+    
+    # Add message to communication
+    state["messages"] = state.get("messages", []) + [{
+        "role": "ai",
+        "content": f"[RAGAnalyzer] I've provided insights on your portfolio and individual stocks based on value investing principles from Security Analysis by Graham and Dodd."
+    }]
+    
+    return state 

agents/recommendation_engine.py

@@ -0,0 +1,270 @@
+import os
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import ChatPromptTemplate
+from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser
+from typing import Dict, List
+from .state import AgentState
+
+def create_recommendation_engine():
+    """Create a recommendation engine using LangChain."""
+    # Define the function schema for structured output
+    function_def = {
+        "name": "generate_recommendations",
+        "description": "Generate investment recommendations based on portfolio analysis",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "portfolio_summary": {
+                    "type": "string",
+                    "description": "Summary of the current portfolio status"
+                },
+                "recommendations": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "ticker": {
+                                "type": "string",
+                                "description": "Stock ticker symbol"
+                            },
+                            "action": {
+                                "type": "string",
+                                "enum": ["BUY", "SELL", "HOLD"],
+                                "description": "Recommended action for this stock"
+                            },
+                            "reasoning": {
+                                "type": "string",
+                                "description": "Detailed reasoning for the recommendation"
+                            },
+                            "priority": {
+                                "type": "integer",
+                                "description": "Priority level (1-5, where 1 is highest priority)",
+                                "minimum": 1,
+                                "maximum": 5
+                            }
+                        },
+                        "required": ["ticker", "action", "reasoning", "priority"]
+                    }
+                },
+                "portfolio_strengths": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "description": "Key strength of the portfolio"
+                    },
+                    "description": "List of portfolio strengths"
+                },
+                "portfolio_weaknesses": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "description": "Key weakness or area for improvement in the portfolio"
+                    },
+                    "description": "List of portfolio weaknesses or areas for improvement"
+                },
+                "allocation_advice": {
+                    "type": "string",
+                    "description": "Advice on portfolio allocation and diversification"
+                },
+                "risk_assessment": {
+                    "type": "string",
+                    "description": "Assessment of portfolio risk relative to user's risk tolerance"
+                },
+                "final_report": {
+                    "type": "string",
+                    "description": "Comprehensive final report with all recommendations and analysis"
+                }
+            },
+            "required": ["portfolio_summary", "recommendations", "portfolio_strengths", "portfolio_weaknesses", "allocation_advice", "risk_assessment", "final_report"]
+        }
+    }
+    
+    # Create prompt template
+    prompt = ChatPromptTemplate.from_template("""
+    You are an expert financial advisor. Based on the following information, provide personalized investment recommendations.
+    
+    PORTFOLIO:
+    {portfolio}
+    
+    RISK PROFILE:
+    {risk_level}
+    
+    INVESTMENT GOALS:
+    {investment_goals}
+    
+    TECHNICAL ANALYSIS:
+    {technical_analysis}
+    
+    FUNDAMENTAL DATA:
+    {fundamental_data}
+    
+    RELEVANT NEWS:
+    {news}
+    
+    SECURITY ANALYSIS INSIGHTS (Graham & Dodd):
+    {rag_insights}
+    
+    AGENT DISCUSSIONS:
+    {agent_discussions}
+    
+    Provide comprehensive investment recommendations that incorporate:
+    1. Technical analysis signals (RSI, moving averages, etc.)
+    2. Fundamental analysis metrics (PE ratios, debt-to-equity, growth rates, etc.)
+    3. Recent news sentiment and impact
+    4. Value investing principles from Graham & Dodd's Security Analysis
+    5. Alignment with the user's risk profile and investment goals
+    
+    For each holding, provide a clear BUY/SELL/HOLD recommendation with detailed reasoning and priority level.
+    
+    IMPORTANT: For the reasoning of each recommendation, include a more detailed technical and fundamental analysis section:
+    - For technical analysis: Include specific insights about RSI levels, MACD signals, moving average crossovers, and what these indicators suggest about momentum and trend direction.
+    - For fundamental analysis: Include specific metrics like P/E ratio compared to industry average, debt-to-equity ratio, earnings growth, and what these metrics suggest about the company's valuation and financial health.
+    - Use technical jargon appropriately to demonstrate expertise while still being clear.
+    - Format the reasoning to clearly separate technical insights from fundamental insights.
+    
+    Identify 3-5 key strengths and weaknesses of the current portfolio.
+    Assess the overall risk and provide allocation advice.
+    
+    Remember that your recommendations will be presented to a busy executive who needs concise, actionable insights.
+    Focus on clarity and brevity in your explanations.
+    """)
+    
+    # Create LLM
+    llm = ChatOpenAI(model="gpt-4-turbo", temperature=0.2)
+    
+    # Create chain
+    chain = (
+        prompt 
+        | llm.bind_functions(functions=[function_def], function_call="generate_recommendations")
+        | JsonOutputFunctionsParser()
+    )
+    
+    return chain
+
+# Initialize recommendation engine
+recommendation_engine_chain = create_recommendation_engine()
+
+def recommendation_engine(state: AgentState) -> AgentState:
+    """Generates investment recommendations based on all analyses including RAG insights."""
+    portfolio = state["portfolio_data"]
+    risk_level = state["risk_level"]
+    investment_goals = state["investment_goals"]
+    tech_analysis = state.get("technical_analysis", {})
+    news = state.get("news_analysis", [])
+    rag_insights = state.get("rag_context", "No RAG insights available.")
+    messages = state.get("messages", [])
+    fundamental_analysis = state.get("fundamental_analysis", {})
+    
+    # Extract fundamental data and RAG interpretations from technical analysis
+    fundamental_data = {}
+    rag_interpretations = {}
+    
+    for ticker in tech_analysis:
+        # Extract fundamental data
+        if isinstance(tech_analysis[ticker], dict):
+            if 'fundamental_data' in tech_analysis[ticker]:
+                fundamental_data[ticker] = tech_analysis[ticker]['fundamental_data']
+            
+            # Extract RAG interpretations
+            if 'rag_interpretation' in tech_analysis[ticker]:
+                rag_interpretations[ticker] = tech_analysis[ticker]['rag_interpretation']
+    
+    # Combine RAG interpretations with portfolio-level insights
+    combined_rag_insights = rag_insights
+    if rag_interpretations:
+        combined_rag_insights += "\n\n## Stock-Specific Interpretations:\n\n"
+        for ticker, interpretation in rag_interpretations.items():
+            combined_rag_insights += f"### {ticker}:\n{interpretation}\n\n"
+    
+    # Format agent discussions
+    agent_discussions = "\n\n".join([f"{msg['role']}: {msg['content']}" for msg in messages])
+    
+    # Invoke recommendation engine
+    try:
+        result = recommendation_engine_chain.invoke({
+            "portfolio": str(portfolio),
+            "risk_level": risk_level,
+            "investment_goals": investment_goals,
+            "technical_analysis": str(tech_analysis),
+            "fundamental_data": str(fundamental_data),
+            "news": str(news),
+            "rag_insights": combined_rag_insights,
+            "agent_discussions": agent_discussions
+        })
+        
+        # Ensure we have all required fields
+        if "recommendations" not in result or not result["recommendations"]:
+            # Generate default recommendations if none were provided
+            result["recommendations"] = []
+            for ticker in portfolio:
+                result["recommendations"].append({
+                    "ticker": ticker,
+                    "action": "HOLD",
+                    "reasoning": "Default recommendation due to insufficient analysis data.",
+                    "priority": 3
+                })
+        
+        if "final_report" not in result or not result["final_report"]:
+            # Generate a default final report
+            result["final_report"] = f"""
+            # Investment Portfolio Analysis Report
+            
+            ## Portfolio Overview
+            Risk Level: {risk_level}
+            Investment Goals: {investment_goals}
+            
+            ## Key Recommendations
+            {', '.join([f"{rec['ticker']}: {rec['action']}" for rec in result.get("recommendations", [])])}
+            
+            ## Summary
+            This is a default report generated due to insufficient analysis data.
+            """
+        
+        # Ensure other fields exist
+        if "portfolio_strengths" not in result:
+            result["portfolio_strengths"] = ["Diversification across multiple assets"]
+        
+        if "portfolio_weaknesses" not in result:
+            result["portfolio_weaknesses"] = ["Potential for improved sector allocation"]
+        
+        if "allocation_advice" not in result:
+            result["allocation_advice"] = "Consider maintaining a balanced portfolio aligned with your risk tolerance."
+        
+        if "risk_assessment" not in result:
+            result["risk_assessment"] = f"Your portfolio appears to be aligned with your {risk_level} risk tolerance."
+        
+        if "portfolio_summary" not in result:
+            result["portfolio_summary"] = f"Portfolio with {len(portfolio)} assets analyzed."
+        
+    except Exception as e:
+        # Handle any errors in the recommendation engine
+        print(f"Error in recommendation engine: {str(e)}")
+        result = {
+            "recommendations": [],
+            "final_report": f"Error generating recommendations: {str(e)}",
+            "portfolio_strengths": [],
+            "portfolio_weaknesses": [],
+            "allocation_advice": "",
+            "risk_assessment": "",
+            "portfolio_summary": "Error in analysis"
+        }
+    
+    # Update state with recommendations and enhanced data
+    state["recommendations"] = result["recommendations"]
+    state["final_report"] = result["final_report"]
+    
+    # Add new structured data to state
+    state["portfolio_strengths"] = result.get("portfolio_strengths", [])
+    state["portfolio_weaknesses"] = result.get("portfolio_weaknesses", [])
+    state["allocation_advice"] = result.get("allocation_advice", "")
+    state["risk_assessment"] = result.get("risk_assessment", "")
+    
+    # Add message to communication
+    state["messages"] = state.get("messages", []) + [{
+        "role": "ai",
+        "content": f"[RecommendationEngine] I've generated the following recommendations:\n\n{result.get('portfolio_summary', '')}\n\n"
+                   f"Risk Assessment: {result.get('risk_assessment', '')}\n\n"
+                   f"Allocation Advice: {result.get('allocation_advice', '')}"
+    }]
+    
+    return state

agents/state.py

@@ -0,0 +1,63 @@
+from typing import TypedDict, Dict, Any, List, Optional, Annotated
+import operator
+
+# Define state types for LangGraph
+class AgentState(TypedDict):
+    # Input data
+    portfolio_data: Dict[str, Any]
+    risk_level: str
+    investment_goals: str
+    
+    # Analysis data
+    technical_analysis: Dict[str, Any]
+    news_analysis: List[Dict[str, Any]]
+    fundamental_analysis: Dict[str, Any]
+    
+    # RAG data
+    rag_context: Optional[str]
+    
+    # Agent communication
+    messages: Annotated[List[Dict[str, Any]], operator.add]
+    
+    # Output data
+    recommendations: List[Dict[str, str]]
+    portfolio_strengths: List[str]
+    portfolio_weaknesses: List[str]
+    new_investments: List[Dict[str, Any]]
+    allocation_advice: str
+    risk_assessment: str
+    final_report: str 
+
+
+    # Define state types for LangGraph
+class AgentState2(TypedDict):
+    # Input data
+    portfolio_data: Dict[str, Any]
+    risk_level: str
+    investment_goals: str
+    
+    # Analysis data
+    technical_analysis: Dict[str, Any]
+    news_analysis: List[Dict[str, Any]]
+    fundamental_analysis: Dict[str, Any]
+    
+    # New investment workflow data
+    high_rank_stocks: List[Dict[str, Any]]
+    new_stock_analysis: Dict[str, Any]
+    portfolio_fit: Dict[str, Any]
+    
+    # RAG data
+    rag_context: Optional[str]
+    
+    # Agent communication
+    messages: Annotated[List[Dict[str, Any]], operator.add]
+    
+    # Output data
+    recommendations: List[Dict[str, str]]
+    portfolio_strengths: List[str]
+    portfolio_weaknesses: List[str]
+    new_investments: List[Dict[str, Any]]
+    new_investment_summary: str
+    allocation_advice: str
+    risk_assessment: str
+    final_report: str 

agents/technical_analyzer.py

@@ -0,0 +1,150 @@
+import yfinance as yf
+import numpy as np
+import pandas as pd
+from typing import Dict, Any, List
+from .state import AgentState
+
+def calculate_rsi(prices, period=14):
+    """Calculate Relative Strength Index."""
+    # Calculate price changes
+    delta = prices.diff()
+    
+    # Separate gains and losses
+    gain = delta.clip(lower=0)
+    loss = -delta.clip(upper=0)
+    
+    # Calculate average gain and loss
+    avg_gain = gain.rolling(window=period).mean()
+    avg_loss = loss.rolling(window=period).mean()
+    
+    # Calculate relative strength (RS)
+    rs = avg_gain / avg_loss
+    
+    # Calculate RSI
+    rsi = 100 - (100 / (1 + rs))
+    
+    return rsi
+
+def calculate_macd(prices, fast=12, slow=26, signal=9):
+    """Calculate Moving Average Convergence Divergence."""
+    # Calculate EMAs
+    ema_fast = prices.ewm(span=fast, adjust=False).mean()
+    ema_slow = prices.ewm(span=slow, adjust=False).mean()
+    
+    # Calculate MACD line
+    macd_line = ema_fast - ema_slow
+    
+    # Calculate signal line
+    signal_line = macd_line.ewm(span=signal, adjust=False).mean()
+    
+    # Calculate histogram
+    histogram = macd_line - signal_line
+    
+    return {
+        'macd_line': macd_line,
+        'signal_line': signal_line,
+        'histogram': histogram
+    }
+
+def get_technical_indicators(ticker_obj, hist):
+    """Calculate technical indicators for a stock without making judgments."""
+    if hist.empty:
+        return None
+    
+    # Calculate basic technical indicators
+    hist['MA20'] = hist['Close'].rolling(window=20).mean()
+    hist['MA50'] = hist['Close'].rolling(window=50).mean()
+    hist['MA200'] = hist['Close'].rolling(window=200).mean()
+    hist['RSI'] = calculate_rsi(hist['Close'])
+    
+    # Calculate MACD
+    macd = calculate_macd(hist['Close'])
+    hist['MACD_Line'] = macd['macd_line']
+    hist['MACD_Signal'] = macd['signal_line']
+    hist['MACD_Histogram'] = macd['histogram']
+    
+    # Calculate Bollinger Bands
+    hist['BB_Middle'] = hist['Close'].rolling(window=20).mean()
+    std = hist['Close'].rolling(window=20).std()
+    hist['BB_Upper'] = hist['BB_Middle'] + (std * 2)
+    hist['BB_Lower'] = hist['BB_Middle'] - (std * 2)
+    
+    # Get latest values
+    latest = hist.iloc[-1]
+    
+    # Get fundamental data
+    info = ticker_obj.info
+    
+    return {
+        'current_price': latest['Close'],
+        'technical_indicators': {
+            'ma20': latest['MA20'],
+            'ma50': latest['MA50'],
+            'ma200': latest['MA200'],
+            'rsi': latest['RSI'],
+            'macd_line': latest['MACD_Line'],
+            'macd_signal': latest['MACD_Signal'],
+            'macd_histogram': latest['MACD_Histogram'],
+            'bb_upper': latest['BB_Upper'],
+            'bb_middle': latest['BB_Middle'],
+            'bb_lower': latest['BB_Lower'],
+            'volume': latest['Volume']
+        },
+        'fundamental_data': {
+            'symbol': ticker_obj.ticker,
+            'price': info.get('currentPrice'),
+            'pe_ratio': info.get('trailingPE'),
+            'peg_ratio': info.get('pegRatio'),
+            'debt_to_equity': info.get('debtToEquity'),
+            'forward_pe': info.get('forwardPE'),
+            'beta': info.get('beta'),
+            'return_on_equity': info.get('returnOnEquity'),
+            'free_cash_flow': info.get('freeCashflow'),
+            'revenue_growth': info.get('revenueGrowth'),
+            'earnings_growth': info.get('earningsGrowth'),
+            'dividend_yield': info.get('dividendYield'),
+            'market_cap': info.get('marketCap'),
+            'profit_margins': info.get('profitMargins'),
+            'price_to_book': info.get('priceToBook')
+        }
+    }
+
+def technical_analyzer(state: AgentState) -> AgentState:
+    """Performs comprehensive technical analysis on portfolio assets."""
+    portfolio = state["portfolio_data"]
+    
+    tickers = list(portfolio.keys())
+    analysis_results = {}
+    
+    # Collect technical data for all stocks
+    for ticker in tickers:
+        try:
+            # Get stock data
+            stock = yf.Ticker(ticker)
+            hist = stock.history(period="6mo")
+            
+            if not hist.empty:
+                # Get comprehensive technical indicators without judgments
+                indicators = get_technical_indicators(stock, hist)
+                
+                if indicators:
+                    analysis_results[ticker] = indicators
+                else:
+                    analysis_results[ticker] = {"error": "Failed to calculate indicators"}
+            else:
+                analysis_results[ticker] = {"error": "No historical data available"}
+                
+        except Exception as e:
+            print(f"Error analyzing {ticker}: {str(e)}")
+            analysis_results[ticker] = {"error": str(e)}
+    
+    # Update state with technical analysis
+    state["technical_analysis"] = analysis_results
+    
+    # Add message to communication
+    state["messages"] = state.get("messages", []) + [{
+        "role": "ai",
+        "content": f"[TechnicalAnalyzer] I've calculated technical indicators and gathered fundamental data for your portfolio stocks."
+    }]
+    
+    return state

agents/zacks_analyzer.py

@@ -0,0 +1,33 @@
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from zacks import find_rank_1_stocks
+from .state import AgentState
+
+def zacks_analyzer(state: AgentState) -> AgentState:
+    """Fetches high-rank stocks from Zacks for potential new investments."""
+    try:
+        # Get 5 rank 1 stocks from Zacks
+        high_rank_stocks = find_rank_1_stocks(n=15)
+
+        #TODO if really aggressive use sp400
+        
+        # Store the high-rank stocks in the state
+        state["high_rank_stocks"] = high_rank_stocks
+        
+        # Add message to communication
+        stock_symbols = [stock['symbol'] for stock in high_rank_stocks]
+        state["messages"] = state.get("messages", []) + [{
+            "role": "ai",
+            "content": f"[ZacksAnalyzer] I've identified {len(high_rank_stocks)} high-ranked stocks from Zacks: {', '.join(stock_symbols)}"
+        }]
+        
+    except Exception as e:
+        # Handle any errors
+        state["messages"] = state.get("messages", []) + [{
+            "role": "ai",
+            "content": f"[ZacksAnalyzer] Error fetching high-rank stocks: {str(e)}"
+        }]
+        state["high_rank_stocks"] = []
+    
+    return state 

app.py

@@ -0,0 +1,918 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+from langchain_openai import ChatOpenAI
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain_community.vectorstores import Chroma
+import os
+from dotenv import load_dotenv
+import yfinance as yf
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+# Import our agent modules
+from agents import AgentState, AgentState2
+from agents.graph import setup_graph_with_tracking, setup_new_investments_graph
+
+# Load environment variables
+load_dotenv()
+
+# Configure page
+st.set_page_config(
+    page_title="Cardinal ai",
+    page_icon="🧭",
+    layout="wide"
+)
+
+# Initialize OpenAI client
+openai_api_key = os.getenv("OPENAI_API_KEY")
+# llm = ChatOpenAI(model="gpt-4-turbo", temperature=0.2, api_key=openai_api_key)
+
+# # Initialize embedding model
+# embeddings = HuggingFaceEmbeddings(model_name="Snowflake/snowflake-arctic-embed-l")
+
+# # Initialize Vector DB
+# vector_db = Chroma(embedding_function=embeddings, persist_directory="./chroma_db")
+
+# Streamlit UI components
+st.image("assets/sunrise.svg")
+# st.title("Asset Atlas - AI Financial Advisor")
+# st.subheader("Research, Summary, and Analysis")
+
+# with st.expander("About this app", expanded=False):
+#     st.write("""
+#     This app provides personalized financial advice based on your portfolio, risk tolerance, and investment goals.
+#     It analyzes technical indicators, relevant news, and market trends to offer tailored recommendations.
+#     """)
+
+# Sidebar for user inputs
+with st.sidebar:
+    st.header("Your Profile")
+    
+    # Risk tolerance selection
+    risk_level = st.select_slider(
+        "Risk Tolerance",
+        options=["Very Conservative", "Conservative", "Moderate", "Aggressive", "Very Aggressive"],
+        value="Moderate"
+    )
+    
+    # Investment goals
+    investment_goals = st.text_area("Investment Goals", "Retirement in 20 years, building wealth, passive income")
+
+    st.markdown("")
+    
+    # Portfolio input
+    st.header("Your Portfolio")
+    
+    # Default portfolio for demonstration
+    default_portfolio = pd.DataFrame({
+        'Ticker': ['AAPL', 'MSFT', 'GOOGL', 'AMZN', 'BRK-B'],
+        'Shares': [10, 5, 3, 2, 4],
+        'Purchase Price': [250.00, 250.00, 250.00, 250.00, 250.00]
+    })
+    
+    # Let user edit the portfolio
+    portfolio_df = st.data_editor(
+        default_portfolio,
+        column_config={
+            "Ticker": st.column_config.TextColumn("Ticker Symbol"),
+            "Shares": st.column_config.NumberColumn("Number of Shares", min_value=0),
+            "Purchase Price": st.column_config.NumberColumn("Purchase Price ($)", min_value=0.01, format="$%.2f")
+        },
+        num_rows="dynamic",
+        use_container_width=True
+    )
+    
+    generate_button = st.button("Generate Recommendations", type="secondary", use_container_width=True)
+    
+
+# Initialize session state to store our analysis results
+if 'portfolio_analyzed' not in st.session_state:
+    st.session_state.portfolio_analyzed = False
+    
+if 'final_state' not in st.session_state:
+    st.session_state.final_state = None
+    
+if 'portfolio_data' not in st.session_state:
+    st.session_state.portfolio_data = None
+
+# Main content area
+if generate_button or st.session_state.portfolio_analyzed:
+    # If we're here because of the session state, we don't need to re-run the analysis
+    if generate_button:
+        # Convert portfolio dataframe to required format
+        portfolio_data = {}
+        
+        # Create a placeholder for the progress indicator
+        progress_placeholder = st.empty()
+        status_placeholder = st.empty()
+        
+        # Show a spinner while processing
+        with st.spinner("Analyzing your portfolio and generating recommendations..."):
+            progress_placeholder.progress(0, "Starting analysis...")
+            status_placeholder.info("Fetching current market data...")
+            
+            for _, row in portfolio_df.iterrows():
+                ticker = row['Ticker']
+                shares = row['Shares']
+                purchase_price = row['Purchase Price']
+                
+                try:
+                    # Get current price
+                    stock = yf.Ticker(ticker)
+                    current_price = stock.history(period="1d")['Close'].iloc[-1]
+                    
+                    # Calculate values
+                    current_value = current_price * shares
+                    purchase_value = purchase_price * shares
+                    gain_loss = current_value - purchase_value
+                    gain_loss_pct = (gain_loss / purchase_value) * 100
+                    
+                    # Store in portfolio data
+                    portfolio_data[ticker] = {
+                        "shares": shares,
+                        "purchase_price": purchase_price,
+                        "current_price": current_price,
+                        "value": current_value,
+                        "gain_loss": gain_loss,
+                        "gain_loss_pct": gain_loss_pct
+                    }
+                except Exception as e:
+                    st.error(f"Error processing {ticker}: {e}")
+
+                if len(portfolio_data) == len(portfolio_df):
+                    st.subheader("Current valuation")
+                    
+                    # Create a dataframe for portfolio valuation
+                    valuation_data = []
+                    total_value = 0
+                    total_cost = 0
+                    
+                    for ticker, data in portfolio_data.items():
+                        current_value = data['value']
+                        purchase_value = data['purchase_price'] * data['shares']
+                        total_value += current_value
+                        total_cost += purchase_value
+                        
+                        valuation_data.append({
+                            'Ticker': ticker,
+                            'Shares': data['shares'],
+                            'Purchase Price': f"${data['purchase_price']:.2f}",
+                            'Current Price': f"${data['current_price']:.2f}",
+                            'Cost Basis': f"${purchase_value:.2f}",
+                            'Current Value': f"${current_value:.2f}",
+                            'Gain/Loss ($)': f"${data['gain_loss']:.2f}",
+                            'Gain/Loss (%)': f"{data['gain_loss_pct']:.2f}%"
+                        })
+                    
+                    # Calculate total gain/loss
+                    total_gain_loss = total_value - total_cost
+                    total_gain_loss_pct = (total_gain_loss / total_cost * 100) if total_cost > 0 else 0
+                    
+                    # Display the valuation table
+                    valuation_df = pd.DataFrame(valuation_data)
+                    st.dataframe(valuation_df, use_container_width=True)
+                
+
+                # Display portfolio valuations and allocations with gain/loss
+                #if portfolio_data:   
+                    
+                    # Create a better layout with metrics on the left and pie chart on the right
+                    st.subheader("Performance & allocation summary")
+                    
+                    # Create two columns for the layout with adjusted ratio
+                    left_col, right_col = st.columns([1, 1])
+                    
+                    # Left column: stacked metrics
+                    with left_col:
+                        cont_col, gap_col = st.columns([2, 1])
+
+                        with cont_col:
+                            # Add a bit of vertical space for alignment
+                            st.write("")
+                            
+                            # Total Portfolio Value metric
+                            st.metric("Total Portfolio Value", f"${total_value:.2f}", f"${total_gain_loss:.2f}", border=True)
+                            
+                            # Add some space between metrics
+                            st.write("")
+                            
+                            # Total Cost Basis metric
+                            st.metric("Total Cost Basis", f"${total_cost:.2f}", border=True)
+                            
+                            # Add some space between metrics
+                            st.write("")
+                            
+                            # Total Return metric
+                            st.metric("Total Return", f"{total_gain_loss_pct:.2f}%", border=True)
+                        with gap_col:
+                            st.markdown("")
+                    
+                    # Right column: pie chart
+                    with right_col:
+                        # Prepare data for pie chart
+                        st.markdown("")
+                        allocation_data = {}
+                        for ticker, data in portfolio_data.items():
+                            allocation_data[ticker] = data['value']
+                        
+                        # Create a figure for the pie chart
+                        fig, ax = plt.subplots(figsize=(4, 3.2))
+                        
+                        # Create the pie chart
+                        wedges, texts, autotexts = ax.pie(
+                            allocation_data.values(), 
+                            labels=allocation_data.keys(),
+                            autopct='%1.1f%%',
+                            startangle=90,
+                            wedgeprops={'edgecolor': 'white'},
+                            textprops={'fontsize': 8}
+                        )
+                        
+                        # Equal aspect ratio ensures that pie is drawn as a circle
+                        ax.axis('equal')
+                        
+                        # Manually set font sizes
+                        plt.setp(autotexts, size=8, weight="bold")
+                        plt.setp(texts, size=8)
+                        
+                        # Add a title
+                        plt.title('Portfolio Allocation by Value', fontsize=10)
+                        
+                        # Use tight layout
+                        plt.tight_layout()
+                        
+                        # Display the pie chart
+                        st.pyplot(fig)
+            
+            # Initialize state
+            initial_state = AgentState(
+                portfolio_data=portfolio_data,
+                risk_level=risk_level,
+                investment_goals=investment_goals,
+                technical_analysis={},
+                news_analysis=[],
+                fundamental_analysis={},
+                rag_context=None,
+                messages=[{
+                    "role": "human",
+                    "content": f"Please analyze my portfolio with risk level '{risk_level}' and investment goals: '{investment_goals}'."
+                }],
+                next="",
+                recommendations=[],
+                portfolio_strengths=[],
+                portfolio_weaknesses=[],
+                new_investments=[],
+                allocation_advice="",
+                risk_assessment="",
+                final_report=""
+            )
+            
+            # Create a custom callback to track progress
+            def track_progress(state):
+                # Simple progress tracking based on what's in the state
+                # Each node adds its output to the state, so we can use that to determine progress
+                
+                # Check which stage we're at based on what's in the state
+                if "final_report" in state and state["final_report"]:
+                    progress_placeholder.progress(100, "Complete")
+                    status_placeholder.success("Analysis complete!")
+                elif "recommendations" in state and state["recommendations"]:
+                    progress_placeholder.progress(90, "Generating Recommendations")
+                    status_placeholder.info("Recommendations generated. Finalizing report...")
+                elif "rag_context" in state and state["rag_context"]:
+                    progress_placeholder.progress(75, "RAG Analysis")
+                    status_placeholder.info("Value investing analysis complete. Generating recommendations...")
+
+                    ### SHOW NEWS
+                    # Display relevant news with links if available
+                    #if "news_analysis" in final_state and final_state["news_analysis"]:
+                    if state["news_analysis"]:
+                        st.markdown("")
+                        st.subheader("Market news for your portfolio")
+                        
+                        # Display top two news articles outside the expander
+                        top_articles_shown = 0
+                        for i, news_item in enumerate(state["news_analysis"]):
+                            if isinstance(news_item, dict) and top_articles_shown < 2:
+                                title = news_item.get("title", "")
+                                summary = news_item.get("summary", "")
+                                url = news_item.get("url", "")
+                                urlToImage = news_item.get("urlToImage", "")
+                                sentiment = news_item.get("sentiment", "neutral")
+                                if not summary or summary == "No description available.":
+                                    continue
+                                
+                                # Create two columns for image and content
+                                img_col, content_col = st.columns([1, 6])
+                                
+                                # Display image in left column if available
+                                if urlToImage:
+                                    with img_col:
+                                        st.markdown("""
+                                        <style>
+                                        .news-image-container {
+                                            width: 120px;
+                                            height: 120px;
+                                            overflow: hidden;
+                                            display: flex;
+                                            align-items: center;
+                                            justify-content: center;
+                                            border-radius: 8px;
+                                            margin: 8px;
+                                            margin-top: -16px;
+                                        }
+                                        .news-image-container img {
+                                            height: 100%;
+                                            width: auto;
+                                            object-fit: cover;
+                                        }
+                                        </style>
+                                        """, unsafe_allow_html=True)
+                                        
+                                        st.markdown(f"""
+                                        <div class="news-image-container">
+                                            <img src="{urlToImage}" alt="News image">
+                                        </div>
+                                        """, unsafe_allow_html=True)
+                                
+                                # Display title, summary, and link in right column
+                                with content_col:
+                                    # Style based on sentiment
+                                    if sentiment.lower() == "positive":
+                                        st.success(f"**{title}**")
+                                    elif sentiment.lower() == "negative":
+                                        st.error(f"**{title}**")
+                                    else:
+                                        st.info(f"**{title}**")
+                                    
+                                    # Truncate summary to one line (max 120 characters)
+                                    truncated_summary = summary[:120] + "..." if len(summary) > 120 else summary
+                                    st.write(truncated_summary)
+                                    if url:
+                                        st.write(f"[Read more]({url})")
+                                
+                                top_articles_shown += 1
+                        
+                        # Display remaining news articles in the expander
+                        if len(state["news_analysis"]) > 2:
+                            with st.expander("View More Market News"):
+                                for i, news_item in enumerate(state["news_analysis"]):
+                                    if isinstance(news_item, dict) and i >= 2:
+                                        title = news_item.get("title", "")
+                                        summary = news_item.get("summary", "")
+                                        url = news_item.get("url", "")
+                                        urlToImage = news_item.get("urlToImage", "")
+                                        sentiment = news_item.get("sentiment", "neutral")
+                                        if not summary or summary == "No description available.":
+                                            continue
+                                        
+                                        # Create two columns for image and content
+                                        img_col, content_col = st.columns([1, 6])
+                                        
+                                        # Display image in left column if available
+                                        if urlToImage:
+                                            with img_col:
+                                                st.markdown("""
+                                                <style>
+                                                .news-image-container {
+                                                    width: 120px;
+                                                    height: 120px;
+                                                    overflow: hidden;
+                                                    display: flex;
+                                                    align-items: center;
+                                                    justify-content: center;
+                                                    border-radius: 8px;
+                                                    margin: 8px;
+                                                    margin-top: -16px;
+                                                }
+                                                .news-image-container img {
+                                                    height: 100%;
+                                                    width: auto;
+                                                    object-fit: cover;
+                                                }
+                                                </style>
+                                                """, unsafe_allow_html=True)
+                                                
+                                                st.markdown(f"""
+                                                <div class="news-image-container">
+                                                    <img src="{urlToImage}" alt="News image">
+                                                </div>
+                                                """, unsafe_allow_html=True)
+                                        
+                                        # Display title, summary, and link in right column
+                                        with content_col:
+                                            # Style based on sentiment
+                                            if sentiment.lower() == "positive":
+                                                st.success(f"**{title}**")
+                                            elif sentiment.lower() == "negative":
+                                                st.error(f"**{title}**")
+                                            else:
+                                                st.info(f"**{title}**")
+                                            
+                                            # Truncate summary to one line (max 120 characters)
+                                            truncated_summary = summary[:120] + "..." if len(summary) > 120 else summary
+                                            st.write(truncated_summary)
+                                            if url:
+                                                st.write(f"[Read more]({url})")
+
+
+
+
+                elif "news_analysis" in state and state["news_analysis"]:
+                    progress_placeholder.progress(60, "News Analysis")
+                    status_placeholder.info("News analysis complete. Applying value investing principles...")
+                elif "portfolio_analysis" in state and state["portfolio_analysis"]:
+                    progress_placeholder.progress(40, "Portfolio Analysis")
+                    status_placeholder.info("Portfolio analysis complete. Gathering financial news...")
+                elif "technical_analysis" in state and state["technical_analysis"]:
+                    progress_placeholder.progress(20, "Technical Analysis")
+                    status_placeholder.info("Technical analysis complete. Analyzing portfolio...")
+                else:
+                    progress_placeholder.progress(0, "Starting analysis...")
+                    status_placeholder.info("Initializing technical analysis...")
+                
+                return state
+            
+            # Run the graph with progress tracking
+            graph = setup_graph_with_tracking(track_progress)
+            
+            # Run the graph
+            final_state = graph.invoke(initial_state)
+            
+            # Store the final state in session state
+            st.session_state.final_state = final_state
+            st.session_state.portfolio_analyzed = True
+            st.session_state.portfolio_data = portfolio_data
+
+    else:
+        # Use the stored final state
+        final_state = st.session_state.final_state
+        portfolio_data = st.session_state.portfolio_data
+    
+    # Display the results
+    # Display the executive summary for the end user
+    #st.subheader("Your Investment Portfolio Analysis")
+    # if portfolio_data:
+    #     st.subheader("Current valuation")
+        
+    #     # Create a dataframe for portfolio valuation
+    #     valuation_data = []
+    #     total_value = 0
+    #     total_cost = 0
+        
+    #     for ticker, data in portfolio_data.items():
+    #         current_value = data['value']
+    #         purchase_value = data['purchase_price'] * data['shares']
+    #         total_value += current_value
+    #         total_cost += purchase_value
+            
+    #         valuation_data.append({
+    #             'Ticker': ticker,
+    #             'Shares': data['shares'],
+    #             'Purchase Price': f"${data['purchase_price']:.2f}",
+    #             'Current Price': f"${data['current_price']:.2f}",
+    #             'Cost Basis': f"${purchase_value:.2f}",
+    #             'Current Value': f"${current_value:.2f}",
+    #             'Gain/Loss ($)': f"${data['gain_loss']:.2f}",
+    #             'Gain/Loss (%)': f"{data['gain_loss_pct']:.2f}%"
+    #         })
+        
+    #     # Calculate total gain/loss
+    #     total_gain_loss = total_value - total_cost
+    #     total_gain_loss_pct = (total_gain_loss / total_cost * 100) if total_cost > 0 else 0
+        
+    #     # Display the valuation table
+    #     valuation_df = pd.DataFrame(valuation_data)
+    #     st.dataframe(valuation_df, use_container_width=True)
+    
+
+    # # Display portfolio valuations and allocations with gain/loss
+    # #if portfolio_data:   
+         
+    #     # Create a better layout with metrics on the left and pie chart on the right
+    #     st.subheader("Performance & allocation summary")
+        
+    #     # Create two columns for the layout with adjusted ratio
+    #     left_col, right_col = st.columns([1, 1])
+        
+    #     # Left column: stacked metrics
+    #     with left_col:
+    #         cont_col, gap_col = st.columns([2, 1])
+
+    #         with cont_col:
+    #             # Add a bit of vertical space for alignment
+    #             st.write("")
+                
+    #             # Total Portfolio Value metric
+    #             st.metric("Total Portfolio Value", f"${total_value:.2f}", f"${total_gain_loss:.2f}", border=True)
+                
+    #             # Add some space between metrics
+    #             st.write("")
+                
+    #             # Total Cost Basis metric
+    #             st.metric("Total Cost Basis", f"${total_cost:.2f}", border=True)
+                
+    #             # Add some space between metrics
+    #             st.write("")
+                
+    #             # Total Return metric
+    #             st.metric("Total Return", f"{total_gain_loss_pct:.2f}%", border=True)
+    #         with gap_col:
+    #             st.markdown("")
+        
+    #     # Right column: pie chart
+    #     with right_col:
+    #         # Prepare data for pie chart
+    #         st.markdown("")
+    #         allocation_data = {}
+    #         for ticker, data in portfolio_data.items():
+    #             allocation_data[ticker] = data['value']
+            
+    #         # Create a figure for the pie chart
+    #         fig, ax = plt.subplots(figsize=(4, 3.2))
+            
+    #         # Create the pie chart
+    #         wedges, texts, autotexts = ax.pie(
+    #             allocation_data.values(), 
+    #             labels=allocation_data.keys(),
+    #             autopct='%1.1f%%',
+    #             startangle=90,
+    #             wedgeprops={'edgecolor': 'white'},
+    #             textprops={'fontsize': 8}
+    #         )
+            
+    #         # Equal aspect ratio ensures that pie is drawn as a circle
+    #         ax.axis('equal')
+            
+    #         # Manually set font sizes
+    #         plt.setp(autotexts, size=8, weight="bold")
+    #         plt.setp(texts, size=8)
+            
+    #         # Add a title
+    #         plt.title('Portfolio Allocation by Value', fontsize=10)
+            
+    #         # Use tight layout
+    #         plt.tight_layout()
+            
+    #         # Display the pie chart
+    #         st.pyplot(fig)
+
+    # Check if we have a final report
+    if "final_report" in final_state and final_state["final_report"]:
+        st.subheader("Portfolio analysis")
+        # Format and display the final report in a clean, professional way
+        report = final_state["final_report"]
+        #st.markdown(report)
+        # st.markdown(
+        #     f"""
+        #     <div style="background-color: #060F35;">
+        #         {report}
+        #     </div>
+        #     """, 
+        #     unsafe_allow_html=True
+        # )
+        st.info(report)
+    else:
+        st.error("Unable to generate portfolio analysis. Please try again.")
+
+    # Display relevant news with links if available
+    #if "news_analysis" in final_state and final_state["news_analysis"]:
+    # if final_state["news_analysis"]:
+    #     st.markdown("")
+    #     st.subheader("Market news for your portfolio")
+        
+    #     # Display top two news articles outside the expander
+    #     top_articles_shown = 0
+    #     for i, news_item in enumerate(final_state["news_analysis"]):
+    #         if isinstance(news_item, dict) and top_articles_shown < 2:
+    #             title = news_item.get("title", "")
+    #             summary = news_item.get("summary", "")
+    #             url = news_item.get("url", "")
+    #             urlToImage = news_item.get("urlToImage", "")
+    #             sentiment = news_item.get("sentiment", "neutral")
+    #             if not summary or summary == "No description available.":
+    #                 continue
+                
+    #             # Create two columns for image and content
+    #             img_col, content_col = st.columns([1, 6])
+                
+    #             # Display image in left column if available
+    #             if urlToImage:
+    #                 with img_col:
+    #                     st.markdown("""
+    #                     <style>
+    #                     .news-image-container {
+    #                         width: 120px;
+    #                         height: 120px;
+    #                         overflow: hidden;
+    #                         display: flex;
+    #                         align-items: center;
+    #                         justify-content: center;
+    #                         border-radius: 8px;
+    #                         margin: 8px;
+    #                         margin-top: -16px;
+    #                     }
+    #                     .news-image-container img {
+    #                         height: 100%;
+    #                         width: auto;
+    #                         object-fit: cover;
+    #                     }
+    #                     </style>
+    #                     """, unsafe_allow_html=True)
+                        
+    #                     st.markdown(f"""
+    #                     <div class="news-image-container">
+    #                         <img src="{urlToImage}" alt="News image">
+    #                     </div>
+    #                     """, unsafe_allow_html=True)
+                
+    #             # Display title, summary, and link in right column
+    #             with content_col:
+    #                 # Style based on sentiment
+    #                 if sentiment.lower() == "positive":
+    #                     st.success(f"**{title}**")
+    #                 elif sentiment.lower() == "negative":
+    #                     st.error(f"**{title}**")
+    #                 else:
+    #                     st.info(f"**{title}**")
+                    
+    #                 # Truncate summary to one line (max 120 characters)
+    #                 truncated_summary = summary[:120] + "..." if len(summary) > 120 else summary
+    #                 st.write(truncated_summary)
+    #                 if url:
+    #                     st.write(f"[Read more]({url})")
+                
+    #             top_articles_shown += 1
+        
+    #     # Display remaining news articles in the expander
+    #     if len(final_state["news_analysis"]) > 2:
+    #         with st.expander("View More Market News"):
+    #             for i, news_item in enumerate(final_state["news_analysis"]):
+    #                 if isinstance(news_item, dict) and i >= 2:
+    #                     title = news_item.get("title", "")
+    #                     summary = news_item.get("summary", "")
+    #                     url = news_item.get("url", "")
+    #                     urlToImage = news_item.get("urlToImage", "")
+    #                     sentiment = news_item.get("sentiment", "neutral")
+    #                     if not summary or summary == "No description available.":
+    #                         continue
+                        
+    #                     # Create two columns for image and content
+    #                     img_col, content_col = st.columns([1, 6])
+                        
+    #                     # Display image in left column if available
+    #                     if urlToImage:
+    #                         with img_col:
+    #                             st.markdown("""
+    #                             <style>
+    #                             .news-image-container {
+    #                                 width: 120px;
+    #                                 height: 120px;
+    #                                 overflow: hidden;
+    #                                 display: flex;
+    #                                 align-items: center;
+    #                                 justify-content: center;
+    #                                 border-radius: 8px;
+    #                                 margin: 8px;
+    #                                 margin-top: -16px;
+    #                             }
+    #                             .news-image-container img {
+    #                                 height: 100%;
+    #                                 width: auto;
+    #                                 object-fit: cover;
+    #                             }
+    #                             </style>
+    #                             """, unsafe_allow_html=True)
+                                
+    #                             st.markdown(f"""
+    #                             <div class="news-image-container">
+    #                                 <img src="{urlToImage}" alt="News image">
+    #                             </div>
+    #                             """, unsafe_allow_html=True)
+                        
+    #                     # Display title, summary, and link in right column
+    #                     with content_col:
+    #                         # Style based on sentiment
+    #                         if sentiment.lower() == "positive":
+    #                             st.success(f"**{title}**")
+    #                         elif sentiment.lower() == "negative":
+    #                             st.error(f"**{title}**")
+    #                         else:
+    #                             st.info(f"**{title}**")
+                            
+    #                         # Truncate summary to one line (max 120 characters)
+    #                         truncated_summary = summary[:120] + "..." if len(summary) > 120 else summary
+    #                         st.write(truncated_summary)
+    #                         if url:
+    #                             st.write(f"[Read more]({url})")
+                        
+    
+    # Display portfolio strengths and weaknesses
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.subheader("Portfolio strengths")
+        strengths = final_state.get("portfolio_strengths", [])
+        if strengths:
+            for strength in strengths:
+                st.write(f"✅ {strength}")
+        else:
+            st.write("No specific strengths identified.")
+            
+    with col2:
+        st.subheader("Areas for improvement")
+        weaknesses = final_state.get("portfolio_weaknesses", [])
+        if weaknesses:
+            for weakness in weaknesses:
+                st.write(f"⚠️ {weakness}")
+        else:
+            st.write("No specific areas for improvement identified.")
+    
+    # Display allocation advice and risk assessment
+    st.subheader("Investment strategy")
+    
+    allocation_advice = final_state.get("allocation_advice", "")
+    risk_assessment = final_state.get("risk_assessment", "")
+    
+    if allocation_advice:
+        st.write(f"**Allocation advice:** {allocation_advice}")
+        
+    if risk_assessment:
+        st.write(f"**Risk assessment:** {risk_assessment}")
+
+    # Display key recommendations in an easy-to-read format
+    if "recommendations" in final_state and final_state["recommendations"]:
+        st.subheader("Key recommendations")
+        
+        # Create columns for recommendation cards
+        cols = st.columns(min(3, len(final_state["recommendations"])))
+        
+        # Sort recommendations by priority (if available)
+        sorted_recommendations = sorted(
+            final_state["recommendations"], 
+            key=lambda x: x.get("priority", 5)
+        )
+        
+        # Display top recommendations in cards
+        for i, rec in enumerate(sorted_recommendations[:3]):  # Show top 3 recommendations
+            with cols[i % 3]:
+                action = rec.get("action", "")
+                ticker = rec.get("ticker", "")
+                reasoning = rec.get("reasoning", "")
+                
+                # Style based on action type
+                if action == "BUY":
+                    st.success(f"**{action}: {ticker}**")
+                elif action == "SELL":
+                    st.error(f"**{action}: {ticker}**")
+                else:  # HOLD
+                    st.info(f"**{action}: {ticker}**")
+                    
+                # Display reasoning with markdown formatting preserved
+                st.markdown(reasoning)
+        
+        # If there are more than 3 recommendations, add a expander for the rest
+        if len(sorted_recommendations) > 3:
+            with st.expander("View all recommendations"):
+                for rec in sorted_recommendations[3:]:
+                    action = rec.get("action", "")
+                    ticker = rec.get("ticker", "")
+                    reasoning = rec.get("reasoning", "")
+                    
+                    # Style based on action type
+                    if action == "BUY":
+                        st.success(f"**{action}: {ticker}**")
+                    elif action == "SELL":
+                        st.error(f"**{action}: {ticker}**")
+                    else:  # HOLD
+                        st.info(f"**{action}: {ticker}**")
+                    
+                    # Display reasoning with markdown formatting preserved
+                    st.markdown(reasoning)
+                    st.divider()
+        
+    # Add a second generate button for new investment recommendations
+    st.divider()
+    st.subheader("Next step: Discover new investment opportunities")
+    st.write("Click the button below to discover new investment opportunities that would complement your portfolio.")
+    
+
+    if st.button("Generate New Investment Recommendations", key="new_inv_button"):
+        # Create a placeholder for the progress bar
+        new_inv_progress_placeholder = st.empty()
+        new_inv_status_placeholder = st.empty()
+        
+        # Get portfolio data from session state
+        portfolio_data = st.session_state.portfolio_data
+        
+        # Initialize the state with user inputs
+        initial_state2 = AgentState2(
+            portfolio_data=portfolio_data,
+            risk_level=risk_level,
+            investment_goals=investment_goals,
+            technical_analysis={},
+            news_analysis=[],
+            fundamental_analysis={},
+            high_rank_stocks=[],
+            new_stock_analysis={},
+            portfolio_fit={},
+            rag_context=None,
+            messages=[{
+                "role": "human",
+                "content": f"Please find new investment opportunities that complement my portfolio with risk level '{risk_level}' and investment goals: '{investment_goals}'."
+            }],
+            recommendations=[],
+            portfolio_strengths=[],
+            portfolio_weaknesses=[],
+            new_investments=[],
+            new_investment_summary="",
+            allocation_advice="",
+            risk_assessment="",
+            final_report=""
+        )
+        
+        # Create a custom callback to track progress
+        def track_new_inv_progress(state):
+            # Simple progress tracking based on what's in the state
+            # Each node adds its output to the state, so we can use that to determine progress
+            
+            # Check which stage we're at based on what's in the state
+            if "new_investments" in state and state["new_investments"]:
+                # Everything completed
+                new_inv_progress_placeholder.progress(100, "Complete")
+                new_inv_status_placeholder.success("Analysis complete!")
+            elif "portfolio_fit" in state and state["portfolio_fit"]:
+                # Portfolio Fit Evaluation completed
+                new_inv_progress_placeholder.progress(75, "Portfolio Fit Evaluation")
+                new_inv_status_placeholder.info("Portfolio fit evaluation complete. Generating investment recommendations...")
+            elif "new_stock_analysis" in state and state["new_stock_analysis"]:
+                # New Stock Analysis completed
+                new_inv_progress_placeholder.progress(50, "New Stock Analysis")
+                new_inv_status_placeholder.info("Technical analysis of new stocks complete. Evaluating portfolio fit...")
+            elif "high_rank_stocks" in state and state["high_rank_stocks"]:
+                # Zacks Analysis completed
+                new_inv_progress_placeholder.progress(25, "Finding High-Ranked Stocks")
+                new_inv_status_placeholder.info("Found high-ranked stocks. Analyzing technical indicators...")
+            else:
+                # Just starting
+                new_inv_progress_placeholder.progress(0, "Starting analysis...")
+                new_inv_status_placeholder.info("Searching for high-ranked stocks...")
+            
+            return state
+        
+        # Run the graph with progress tracking
+        new_inv_graph = setup_new_investments_graph(track_new_inv_progress)
+        
+        # Initialize progress
+        new_inv_progress_placeholder.progress(0, "Starting analysis...")
+        new_inv_status_placeholder.info("Finding high-ranked stocks...")
+        
+        # Run the graph
+        new_inv_final_state = new_inv_graph.invoke(initial_state2)
+        
+        # Clear the progress indicators after completion
+        new_inv_progress_placeholder.empty()
+        new_inv_status_placeholder.empty()
+        
+        # Display the new investment recommendations
+        st.subheader("New investment opportunities")
+        
+        # Display the summary
+        new_investment_summary = new_inv_final_state.get("new_investment_summary", "")
+        if new_investment_summary:
+            st.write(new_investment_summary)
+        
+        # Display the new investment recommendations
+        new_investments = new_inv_final_state.get("new_investments", [])
+        if new_investments:
+            print(new_investments)
+            # Sort recommendations by priority (lower number = higher priority)
+            sorted_investments = sorted(new_investments, key=lambda x: x.get("priority", 999) if isinstance(x, dict) else 999)
+            
+            # Create a 3-column layout for recommendations
+            cols = st.columns(3)
+            
+            # Display top recommendations
+            for i, inv in enumerate(sorted_investments):
+                if isinstance(inv, dict):
+                    with cols[i % 3]:
+                        action = inv.get("action", "")
+                        ticker = inv.get("ticker", "")
+                        reasoning = inv.get("reasoning", "")
+                        
+                        # Style based on action type
+                        if action == "BUY":
+                            st.success(f"**{action}: {ticker}**")
+                        elif action == "SELL":
+                            st.error(f"**{action}: {ticker}**")
+                        else:  # HOLD
+                            st.info(f"**{action}: {ticker}**")
+                            
+                        # Display reasoning with markdown formatting preserved
+                        st.markdown(reasoning)
+        else:
+            st.info("No new investment recommendations were generated. Please try again.")
+else:
+    # Default display when app first loads
+    st.info("Enter your portfolio details and click 'Generate Recommendations' to get personalized investing research, summary, and analysis.")

requirements.txt

@@ -0,0 +1,23 @@
+streamlit
+pandas
+numpy
+matplotlib
+seaborn
+yfinance
+requests
+python-dotenv
+langchain>=0.2.14
+langchain-openai>=0.1.23
+langchain-core>=0.2.35
+langgraph>=0.2.14
+langchain-community
+chromadb
+sentence-transformers
+newsapi-python
+pdfplumber
+jupyter
+tiktoken
+qdrant-client
+arxiv
+langchain-text-splitters
+lxml