UPDATE: mcps updated and deployed to ralway

.gitignore

@@ -8,6 +8,7 @@ wheels/
 
 # Virtual environments
 .venv
+.venv3122
 
 # Environment variables
 .env

.python-version

@@ -1 +1 @@
-3.10
+3.12

Dockerfile

@@ -0,0 +1,42 @@
+# Use Python 3.12 slim image for smaller size
+FROM python:3.12-slim
+
+# Set working directory
+WORKDIR /app
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV STREAMLIT_SERVER_PORT=8501
+ENV STREAMLIT_SERVER_ADDRESS=0.0.0.0
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    g++ \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create non-root user for security
+RUN useradd -m -u 1000 streamlit && \
+    chown -R streamlit:streamlit /app
+USER streamlit
+
+# Expose port (Railway will set $PORT)
+EXPOSE 8501
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:$PORT/_stcore/health || exit 1
+
+# Run the application (Railway will set $PORT)
+CMD ["python", "start_services.py"] 

Home.py

@@ -19,51 +19,41 @@ from sklearn.metrics import mean_squared_error, r2_score
 from sklearn.linear_model import Ridge
 from sklearn.model_selection import GridSearchCV
 from dotenv import load_dotenv
-from openai import OpenAI
-from mcp.client.session import ClientSession
-from mcp.client.stdio import stdio_client
-from mcp import StdioServerParameters, types
 from sklearn.preprocessing import StandardScaler
 
+# Try different import approaches
 try:
-    from resource_monitor import (
-        start_resource_monitoring,
-        resource_monitor,
-    )
-
-    RESOURCE_MONITORING_AVAILABLE = True
+    from langchain_mcp_adapters.client import MultiServerMCPClient
 except ImportError:
-    RESOURCE_MONITORING_AVAILABLE = False
-    st.warning("Resource monitoring not available. Install psutil: pip install psutil")
+    try:
+        from langchain_mcp_adapters import MultiServerMCPClient
+    except ImportError:
+        # Fallback to basic MCP client
+        MultiServerMCPClient = None
+from langgraph.prebuilt import create_react_agent
+from langchain_groq import ChatGroq
+from langchain_core.tools import tool
+
 
 # Load environment variables
 load_dotenv()
 
 # Check if API key exists - support both .env and Streamlit secrets
-api_key = os.getenv("OPENROUTER_API_KEY") or st.secrets.get("OPENROUTER_API_KEY")
-model = os.getenv("MODEL") or st.secrets.get("MODEL")
+os.environ["GROQ_API_KEY"] = os.getenv("GROQ_API_KEY") or st.secrets.get("GROQ_API_KEY")
+model_name = os.getenv("MODEL") or st.secrets.get("MODEL")
 
-if not api_key:
+if not os.environ["GROQ_API_KEY"]:
     st.error(
-        "❌ Error: OPENROUTER_API_KEY not found. Please set it in your environment variables or Streamlit secrets."
+        "❌ Error: GROQ_API_KEY not found. Please set it in your environment variables or Streamlit secrets."
     )
     st.stop()
 
-if not model:
+if not model_name:
     st.error(
         "❌ Error: MODEL not found. Please set it in your environment variables or Streamlit secrets."
     )
     st.stop()
 
-# Configure the client to connect to OpenRouter
-client = OpenAI(
-    base_url="https://openrouter.ai/api/v1",
-    api_key=api_key,
-)
-
-# Global variable to store discovered tools
-discovered_tools = []
-
 
 @st.cache_data(ttl=3600)  # Cache for 1 hour
 def get_available_tickers():
@@ -265,137 +255,6 @@ def search_ticker(ticker_symbol):
         return None
 
 
-async def get_news_data(ticker: str) -> str:
-    """Get news data by calling the news server via MCP."""
-    try:
-        # Set up MCP server parameters
-
-        current_dir = os.path.dirname(os.path.abspath(__file__))
-        news_server_path = os.path.join(current_dir, "news_server.py")
-
-        if not os.path.exists(news_server_path):
-            return f"Error: news_server.py not found at {news_server_path}"
-
-        # Use the same Python executable as the current process
-        python_executable = sys.executable
-        server_params = StdioServerParameters(
-            command=python_executable, args=[news_server_path]
-        )
-
-        # Connect to the MCP server
-        try:
-            async with stdio_client(server_params) as (read, write):
-                async with ClientSession(read, write) as session:
-                    # Initialize the session
-                    await session.initialize()
-
-                    # Call the get_latest_news tool
-                    with st.status(
-                        f"🔍 Fetching news data for {ticker}...", expanded=False
-                    ) as status:
-                        try:
-                            result = await asyncio.wait_for(
-                                session.call_tool(
-                                    "get_latest_news", {"ticker": ticker}
-                                ),
-                                timeout=30.0,  # 30 second timeout
-                            )
-                            status.update(
-                                label=f"✅ News data fetched for {ticker}",
-                                state="complete",
-                            )
-                        except asyncio.TimeoutError:
-                            status.update(
-                                label="❌ News data fetch timed out", state="error"
-                            )
-                            return f"Timeout getting news for {ticker}"
-                        except Exception as e:
-                            status.update(
-                                label=f"❌ Error fetching news: {e}", state="error"
-                            )
-                            return f"Error getting news for {ticker}: {e}"
-
-                    # Parse the result properly
-                    if result.content:
-                        for content in result.content:
-                            if isinstance(content, types.TextContent):
-                                return content.text
-
-                    return f"No news data returned for {ticker}"
-        except Exception as e:
-            st.error(f"❌ Failed to connect to news server: {e}")
-            return f"Failed to connect to news server: {e}"
-
-    except Exception as e:
-        return f"Error getting news for {ticker}: {e}"
-
-
-async def get_stock_data(ticker: str) -> str:
-    """Get stock data by calling the stock server via MCP."""
-    try:
-        # Set up MCP server parameters
-
-        current_dir = os.path.dirname(os.path.abspath(__file__))
-        stock_server_path = os.path.join(current_dir, "stock_data_server.py")
-
-        if not os.path.exists(stock_server_path):
-            return f"Error: stock_data_server.py not found at {stock_server_path}"
-
-        # Use the same Python executable as the current process
-        python_executable = sys.executable
-        server_params = StdioServerParameters(
-            command=python_executable, args=[stock_server_path]
-        )
-
-        # Connect to the MCP server
-        try:
-            async with stdio_client(server_params) as (read, write):
-                async with ClientSession(read, write) as session:
-                    # Initialize the session
-                    await session.initialize()
-
-                    # Call the get_historical_stock_data tool
-                    with st.status(
-                        f"📊 Fetching stock data for {ticker}...", expanded=False
-                    ) as status:
-                        try:
-                            result = await asyncio.wait_for(
-                                session.call_tool(
-                                    "get_historical_stock_data", {"ticker": ticker}
-                                ),
-                                timeout=30.0,  # 30 second timeout
-                            )
-                            status.update(
-                                label=f"✅ Stock data fetched for {ticker}",
-                                state="complete",
-                            )
-                        except asyncio.TimeoutError:
-                            status.update(
-                                label="❌ Stock data fetch timed out", state="error"
-                            )
-                            return f"Timeout getting stock data for {ticker}"
-                        except Exception as e:
-                            status.update(
-                                label=f"❌ Error fetching stock data: {e}",
-                                state="error",
-                            )
-                            return f"Error getting stock data for {ticker}: {e}"
-
-                    # Parse the result properly
-                    if result.content:
-                        for content in result.content:
-                            if isinstance(content, types.TextContent):
-                                return content.text
-
-                    return f"No stock data returned for {ticker}"
-        except Exception as e:
-            st.error(f"❌ Failed to connect to stock data server: {e}")
-            return f"Failed to connect to stock data server: {e}"
-
-    except Exception as e:
-        return f"Error getting stock data for {ticker}: {e}"
-
-
 def calculate_rsi(data, window):
     """Calculate RSI (Relative Strength Index) for the given data."""
     delta = data.diff()
@@ -417,10 +276,6 @@ def create_stock_chart(ticker: str):
             stock = yf.Ticker(ticker)
             hist_data = stock.history(period="5y")
 
-            # Track yfinance API call
-            if RESOURCE_MONITORING_AVAILABLE:
-                resource_monitor.increment_yfinance_calls()
-
         if hist_data.empty:
             st.warning(f"No data available for {ticker}")
             return None
@@ -614,10 +469,6 @@ def create_stock_chart(ticker: str):
 
         # Track training time
         training_time = time.time() - start_time
-        if RESOURCE_MONITORING_AVAILABLE:
-            resource_monitor.add_ridge_training_time(
-                training_time
-            )  # Updated method name
 
         # Get the best alpha value for display
         best_alpha = grid_search.best_params_["alpha"]
@@ -844,10 +695,6 @@ def create_stock_chart(ticker: str):
         # Make predictions for the next 30 trading days
         future_predictions = model.predict(X_future_scaled)
 
-        # Track ML predictions
-        if RESOURCE_MONITORING_AVAILABLE:
-            resource_monitor.increment_ml_predictions()
-
         # Create interactive chart with historical data and future predictions
         fig = go.Figure()
 
@@ -1015,48 +862,6 @@ def create_basic_stock_chart(ticker: str):
         return None
 
 
-def initialize_tools():
-    """Initialize the available tools."""
-    global discovered_tools
-
-    discovered_tools = [
-        {
-            "type": "function",
-            "function": {
-                "name": "get_latest_news",
-                "description": "Fetches recent news headlines and descriptions for a specific stock ticker. Use this when user asks about news, updates, or recent events about a company.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "ticker": {
-                            "type": "string",
-                            "description": "The stock ticker symbol (e.g., 'AAPL', 'GOOG', 'TSLA'). Must be a valid stock symbol.",
-                        }
-                    },
-                    "required": ["ticker"],
-                },
-            },
-        },
-        {
-            "type": "function",
-            "function": {
-                "name": "get_historical_stock_data",
-                "description": "Fetches recent historical stock data (Open, High, Low, Close, Volume) for a given ticker. Use this when user asks about stock performance, price data, or market performance.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "ticker": {
-                            "type": "string",
-                            "description": "The stock ticker symbol (e.g., 'AAPL', 'TSLA', 'MSFT'). Must be a valid stock symbol.",
-                        }
-                    },
-                    "required": ["ticker"],
-                },
-            },
-        },
-    ]
-
-
 async def execute_tool_call(tool_call):
     """Execute a tool call using MCP servers."""
     try:
@@ -1153,7 +958,7 @@ async def run_agent(user_query, selected_ticker):
         # Get initial response from the model
         with st.spinner("🤖 Generating analysis..."):
             response = client.chat.completions.create(
-                model=model,
+                model=model_name,
                 messages=messages,
                 tools=discovered_tools,
                 tool_choice="required",
@@ -1192,7 +997,7 @@ async def run_agent(user_query, selected_ticker):
             # Get final response from the model
             with st.spinner("🤖 Finalizing analysis..."):
                 final_response = client.chat.completions.create(
-                    model="openai/gpt-4o-mini",  # Try a different model
+                    model=model_name,
                     messages=messages,
                 )
 
@@ -1211,6 +1016,286 @@ async def run_agent(user_query, selected_ticker):
         return "Please try again with a different question."
 
 
+async def initialize_mcp_agent(model, tools):
+    """Initialize the MCP agent using LangGraph React agent"""
+    try:
+        # Create MCP agent using LangGraph React agent
+        try:
+            # Bind model with system message
+            system_message = """You are a helpful financial assistant. You have access to tools that can fetch stock data and news. 
+            When asked about a stock, use the available tools to get the latest information and provide a comprehensive analysis.
+            Always be helpful and provide detailed insights based on the data you gather."""
+
+            model_with_system = model.bind(system=system_message)
+
+            # Create React agent with tools
+            agent = create_react_agent(
+                model_with_system,
+                tools,
+            )
+            print(f"✅ Created agent with {len(tools)} tools")
+
+        except Exception as e:
+            st.error(f"❌ Failed to create MCP agent: {str(e)}")
+            print(f"❌ MCP agent creation error: {str(e)}")
+            import traceback
+
+            print(f"❌ MCP agent creation traceback: {traceback.format_exc()}")
+            return None
+
+        # Test the agent with LangGraph
+        try:
+            # Use LangGraph ainvoke method for async tools
+            test_result = await agent.ainvoke(
+                {
+                    "messages": [
+                        {"role": "user", "content": "What tools do you have available?"}
+                    ]
+                }
+            )
+            print(f"🔍 Test result: {test_result}")
+        except Exception as e:
+            st.warning(f"⚠️ MCP agent test failed: {str(e)}")
+            print(f"❌ MCP agent test error: {str(e)}")
+            import traceback
+
+            print(f"❌ MCP agent test traceback: {traceback.format_exc()}")
+
+        return agent
+
+    except Exception as e:
+        st.error(f"❌ Error initializing MCP agent: {str(e)}")
+        st.error(f"Error type: {type(e).__name__}")
+        import traceback
+
+        st.error(f"Full traceback: {traceback.format_exc()}")
+        return None
+
+
+async def run_agent_with_mcp(user_query: str, selected_ticker: str = None):
+    """Run the agent using LangGraph React agent"""
+    try:
+        # Get tools and model from session state
+        if "mcp_tools" not in st.session_state or "mcp_model" not in st.session_state:
+            return "❌ MCP tools and model not initialized. Please restart the application."
+
+        tools = st.session_state.mcp_tools
+        model = st.session_state.mcp_model
+
+        # Initialize agent if not already done
+        if "mcp_agent" not in st.session_state or st.session_state.mcp_agent is None:
+            agent = await initialize_mcp_agent(model, tools)
+            if not agent:
+                return "Failed to initialize MCP agent"
+            st.session_state.mcp_agent = agent
+        else:
+            agent = st.session_state.mcp_agent
+
+        # Construct the query with system instructions
+        if selected_ticker:
+            full_query = f"""You are a financial assistant. Use the available tools to get data for {selected_ticker} and then provide a comprehensive analysis.
+
+AVAILABLE TOOLS:
+- get_latest_news: Get recent news for a ticker
+- get_historical_stock_data: Get stock performance data for a ticker
+
+INSTRUCTIONS:
+1. Call get_latest_news with {{"ticker": "{selected_ticker}"}}
+2. Call get_historical_stock_data with {{"ticker": "{selected_ticker}"}}
+3. After getting the data, provide a comprehensive analysis answering: {user_query}
+
+IMPORTANT: After calling the tools, you MUST provide a final analysis with insights, trends, and recommendations. Do not just show the tool calls.
+
+Question: {user_query} for {selected_ticker}"""
+        else:
+            full_query = user_query
+
+        # Run the agent with LangGraph
+        with st.spinner("🤖 Processing with MCP agent..."):
+            try:
+                # Use LangGraph ainvoke method for async tools
+                result = await agent.ainvoke(
+                    {"messages": [{"role": "user", "content": full_query}]}
+                )
+
+                # Debug: Log the result
+                print(f"🔍 MCP Agent Result: {result}")
+
+                # Extract the final answer from the result
+                if isinstance(result, dict) and "output" in result:
+                    final_response = result["output"]
+                elif isinstance(result, str):
+                    final_response = result
+                else:
+                    final_response = str(result)
+
+                # Debug: Print the result type and structure
+                print(f"🔍 Result type: {type(result)}")
+                if isinstance(result, dict):
+                    print(f"🔍 Result keys: {list(result.keys())}")
+                print(f"🔍 Final response type: {type(final_response)}")
+
+                # If the response contains multiple messages, extract only the final AI response
+                if "AIMessage" in final_response:
+                    # Debug: Print the response structure
+                    print(f"🔍 Response structure: {final_response[:500]}...")
+
+                    # Look for the last AIMessage with content
+                    ai_messages = re.findall(
+                        r"AIMessage\(content=\'(.*?)\',", final_response, re.DOTALL
+                    )
+                    if ai_messages:
+                        final_response = ai_messages[-1]  # Get the last AI message
+                        print(f"✅ Extracted AI message: {final_response[:100]}...")
+                    else:
+                        # Try alternative pattern without the comma
+                        ai_messages = re.findall(
+                            r"AIMessage\(content=\'(.*?)\'", final_response, re.DOTALL
+                        )
+                        if ai_messages:
+                            final_response = ai_messages[-1]
+                            print(
+                                f"✅ Extracted AI message (alt): {final_response[:100]}..."
+                            )
+                        else:
+                            print("❌ No AI messages found in response")
+                            # Try to find any content after the last ToolMessage
+                            if "ToolMessage" in final_response:
+                                # Split by ToolMessage and take the last part
+                                parts = final_response.split("ToolMessage")
+                                if len(parts) > 1:
+                                    last_part = parts[-1]
+                                    # Look for AIMessage in the last part
+                                    ai_match = re.search(
+                                        r"AIMessage\(content=\'(.*?)\'",
+                                        last_part,
+                                        re.DOTALL,
+                                    )
+                                    if ai_match:
+                                        final_response = ai_match.group(1)
+                                        print(
+                                            f"✅ Extracted from last part: {final_response[:100]}..."
+                                        )
+
+                # Clean up the final response to remove escaped characters
+                final_response = (
+                    final_response.replace("\\n", "\n")
+                    .replace("\\'", "'")
+                    .replace('\\"', '"')
+                )
+
+                # Check if response is incomplete (only shows tool calls)
+                if "[TOOL_CALLS" in final_response and (
+                    "Final Answer:" not in final_response
+                    and "Based on" not in final_response
+                ):
+                    st.warning("⚠️ Agent response incomplete - only tool calls detected")
+                    st.info("🔄 Trying to get complete response...")
+                    # Try a simpler query to get the final analysis
+                    try:
+                        simple_query = f"Provide a comprehensive analysis of {selected_ticker} based on the latest news and stock data."
+                        simple_result = await agent.ainvoke(
+                            {"messages": [{"role": "user", "content": simple_query}]}
+                        )
+
+                        if (
+                            isinstance(simple_result, dict)
+                            and "output" in simple_result
+                        ):
+                            simple_response = simple_result["output"]
+                        else:
+                            simple_response = str(simple_result)
+
+                        if len(simple_response) > 100:
+                            return simple_response
+                        else:
+                            return f"Tool execution started but final analysis incomplete. Please try again."
+                    except Exception as e2:
+                        return f"Tool execution started but final analysis failed: {str(e2)}"
+
+                # Look for the final answer section
+                if "Final Answer:" in final_response:
+                    # Extract everything after "Final Answer:"
+                    final_answer = final_response.split("Final Answer:")[-1].strip()
+                    return final_answer
+                elif "Thought:" in final_response and "Action:" in final_response:
+                    # If it contains thought process, try to extract the final analysis
+                    # Look for the last meaningful paragraph
+                    lines = final_response.split("\n")
+                    final_lines = []
+                    for line in reversed(lines):
+                        if (
+                            line.strip()
+                            and not line.startswith("Thought:")
+                            and not line.startswith("Action:")
+                            and not line.startswith("Observation:")
+                        ):
+                            final_lines.insert(0, line)
+                        elif line.strip() and (
+                            "Based on" in line
+                            or "Recommendation:" in line
+                            or "Conclusion:" in line
+                        ):
+                            final_lines.insert(0, line)
+                    if final_lines:
+                        return "\n".join(final_lines)
+                    else:
+                        return final_response
+                else:
+                    # Always return a string as a fallback
+                    return str(final_response)
+            except Exception as e:
+                st.error(f"❌ Error during agent execution: {str(e)}")
+                st.error(f"Error type: {type(e).__name__}")
+                import traceback
+
+                st.error(f"Full traceback: {traceback.format_exc()}")
+                # Log to console
+                print(f"❌ MCP Agent Execution Error: {str(e)}")
+                print(f"Error type: {type(e).__name__}")
+                print(f"Full traceback: {traceback.format_exc()}")
+
+                # Check if it's a TaskGroup error
+                if "TaskGroup" in str(e):
+                    st.error(
+                        "❌ TaskGroup error - this might be due to MCP server connection issues"
+                    )
+                    st.info("🔄 Trying to restart MCP agent...")
+                    # Clear the agent and try to reinitialize
+                    if "mcp_agent" in st.session_state:
+                        del st.session_state.mcp_agent
+                    return "Please try again - MCP agent will be reinitialized"
+                else:
+                    # Try a different approach - use the agent's available methods
+                    st.info("🔄 Trying alternative execution method...")
+                    try:
+                        # Try using the agent's available methods
+                        if hasattr(agent, "arun"):
+                            result = await agent.arun(full_query)
+                        elif hasattr(agent, "run"):
+                            result = await agent.run(
+                                full_query
+                            )  # Always await async methods
+                        else:
+                            result = "Agent has no available execution methods"
+                        return result
+                    except Exception as e2:
+                        st.error(f"❌ Alternative execution also failed: {str(e2)}")
+                        st.error(f"Error type: {type(e2).__name__}")
+                        import traceback
+
+                        st.error(f"Full traceback: {traceback.format_exc()}")
+                        # Log to console
+                        print(f"❌ MCP Alternative Execution Error: {str(e2)}")
+                        print(f"Error type: {type(e2).__name__}")
+                        print(f"Full traceback: {traceback.format_exc()}")
+                        return f"Error: {str(e2)}"
+
+    except Exception as e:
+        st.error(f"❌ Error running MCP agent: {e}")
+        return f"Error: {e}"
+
+
 @st.cache_data(ttl=1800)  # Cache for 30 minutes
 def display_top_news(ticker: str):
     """Display top news headlines for the given ticker with clickable links."""
@@ -1357,14 +1442,62 @@ def main():
         "Get comprehensive financial analysis and insights for your selected stocks."
     )
 
-    # Initialize resource monitoring
-    if RESOURCE_MONITORING_AVAILABLE:
-        if "resource_monitoring_started" not in st.session_state:
-            start_resource_monitoring()
-            st.session_state.resource_monitoring_started = True
+    # Initialize MCP client and tools silently
+    try:
+        # Initialize MCP client with proper configuration
+        if MultiServerMCPClient is None:
+            st.error(
+                "❌ MultiServerMCPClient not available. Please install langchain-mcp-adapters"
+            )
+            st.stop()
 
-    # Initialize tools
-    initialize_tools()
+        try:
+            # Pass servers configuration as positional argument
+            client = MultiServerMCPClient(
+                {
+                    "news_server": {
+                        "url": "http://localhost:8001/mcp",
+                        "transport": "streamable_http",
+                    },
+                    "stock_server": {
+                        "url": "http://localhost:8002/mcp",
+                        "transport": "streamable_http",
+                    },
+                }
+            )
+        except Exception as e:
+            # Try with different transport type
+            try:
+                client = MultiServerMCPClient(
+                    {
+                        "news_server": {
+                            "url": "http://localhost:8001/mcp",
+                            "transport": "http",
+                        },
+                        "stock_server": {
+                            "url": "http://localhost:8002/mcp",
+                            "transport": "http",
+                        },
+                    }
+                )
+            except Exception as e2:
+                st.error(f"❌ Failed to initialize MCP client: {str(e2)}")
+                st.stop()
+
+        # Get tools from MCP servers
+        tools = asyncio.run(client.get_tools())
+
+        # Create model with proper configuration
+        model = ChatGroq(model=model_name, temperature=0.1, max_tokens=4096)
+
+        # Store tools and model in session state for later use
+        st.session_state.mcp_tools = tools
+        st.session_state.mcp_model = model
+        st.session_state.mcp_client = client
+
+    except Exception as e:
+        st.error(f"❌ Failed to initialize MCP client: {str(e)}")
+        st.stop()
 
     # Test server availability only once on startup
     if "servers_tested" not in st.session_state:
@@ -1504,29 +1637,50 @@ def main():
             else:
                 st.markdown(
                     f"""
-                <div style=" padding: 10px; border-radius: 10px; margin: 5px 0;">
+                <div style="background-color: #f5f5f5; padding: 10px; border-radius: 10px; margin: 5px 0; border: 1px solid #e0e0e0;">
                     <strong>Agent:</strong>
                 </div>
                 """,
                     unsafe_allow_html=True,
                 )
-                # Render the content as markdown for proper formatting
-                st.markdown(message["content"])
+                # Render the content as markdown for proper formatting with controlled text size
+                st.markdown(
+                    f"""
+                <div style="font-size: 13px; line-height: 1.4; padding: 12px; border-radius: 8px; margin: 5px 0; border-left: 4px solid #007bff; max-height: 400px; overflow-y: auto;"
+                """,
+                    unsafe_allow_html=True,
+                )
+                # Clean up the content to remove raw markdown syntax
+                cleaned_content = (
+                    message["content"].replace("\\n", "\n").replace("\\'", "'")
+                )
+                st.markdown(cleaned_content)
+                st.markdown("</div>", unsafe_allow_html=True)
 
         # Chat input with proper loading state
         if prompt := st.chat_input(f"Ask about {selected_ticker}...", key="chat_input"):
-            # Track streamlit request
-            if RESOURCE_MONITORING_AVAILABLE:
-                resource_monitor.increment_streamlit_requests()
 
             # Add user message to chat history
             st.session_state.messages.append({"role": "user", "content": prompt})
 
             # Display assistant response with spinner above input
             with st.spinner("🤖 Analyzing your request..."):
-                response = asyncio.run(run_agent(prompt, selected_ticker))
+                response = asyncio.run(run_agent_with_mcp(prompt, selected_ticker))
+
+                # Ensure only a string is appended to chat history
+                if isinstance(response, dict) and "content" in response:
+                    clean_response = response["content"]
+                elif (
+                    isinstance(response, list)
+                    and len(response) > 0
+                    and "content" in response[-1]
+                ):
+                    clean_response = response[-1]["content"]
+                else:
+                    clean_response = str(response)
+
                 st.session_state.messages.append(
-                    {"role": "assistant", "content": response}
+                    {"role": "assistant", "content": clean_response}
                 )
 
             # Rerun to display the new message - the chart and news are cached in session state

RAILWAY_DEPLOYMENT.md

@@ -0,0 +1,118 @@
+# Railway Deployment Guide
+
+This guide explains how to deploy the Financial Agent on Railway with all services running on one server.
+
+## Architecture
+
+The deployment runs three services on a single Railway server:
+
+1. **Streamlit App** (Main Port): The main web interface
+2. **MCP Stock Server** (Port + 1): Provides stock data tools
+3. **MCP News Server** (Port + 2): Provides news data tools
+
+## Port Configuration
+
+- **Main Port**: `$PORT` (set by Railway)
+- **Stock Server**: `$PORT + 1`
+- **News Server**: `$PORT + 2`
+
+For example, if Railway assigns port 3000:
+
+- Streamlit: `http://localhost:3000`
+- Stock Server: `http://localhost:3001`
+- News Server: `http://localhost:3002`
+
+## Files Overview
+
+### Core Application Files
+
+- `Home.py` - Main Streamlit application (unchanged)
+- `mcp_stock_server.py` - Stock data MCP server
+- `mcp_news_server.py` - News data MCP server
+
+### Deployment Files
+
+- `start_services.py` - Main startup script that launches all services
+- `update_mcp_urls.py` - Updates MCP server URLs in Home.py
+- `railway.toml` - Railway configuration
+- `Dockerfile` - Container configuration
+
+## Deployment Process
+
+1. **Railway Build**: Railway builds the Docker container
+2. **Startup**: `start_services.py` is executed
+3. **URL Update**: MCP server URLs are updated for the correct ports
+4. **Service Launch**: All three services start in parallel
+5. **Health Check**: Railway monitors the main Streamlit port
+
+## Environment Variables
+
+Set these in Railway dashboard:
+
+```bash
+GROQ_API_KEY=your_groq_api_key_here
+MODEL=mistralai/mistral-small-3.2-24b-instruct:free
+```
+
+## Local Development
+
+To test locally:
+
+```bash
+# Set environment variables
+export PORT=8501
+export GROQ_API_KEY=your_key_here
+export MODEL=mistralai/mistral-small-3.2-24b-instruct:free
+
+# Run the startup script
+python start_services.py
+```
+
+## Troubleshooting
+
+### Services Not Starting
+
+1. Check Railway logs for error messages
+2. Verify all required files are present
+3. Ensure environment variables are set correctly
+
+### MCP Connection Issues
+
+1. Check if MCP servers are running on correct ports
+2. Verify URLs in Home.py are updated correctly
+3. Check network connectivity between services
+
+### Memory Issues
+
+- Railway provides limited memory
+- Consider reducing model complexity if needed
+- Monitor memory usage in Railway dashboard
+
+## Monitoring
+
+- **Main App**: Access via Railway URL
+- **Logs**: Check Railway dashboard for service logs
+- **Health**: Railway monitors `/_stcore/health` endpoint
+
+## Security Notes
+
+- All services run on localhost (internal communication)
+- Only the main Streamlit port is exposed externally
+- MCP servers are not directly accessible from outside
+
+## Customization
+
+To modify the deployment:
+
+1. **Add new services**: Update `start_services.py`
+2. **Change ports**: Modify port calculation logic
+3. **Update configuration**: Edit `railway.toml` or `Dockerfile`
+
+## Support
+
+For deployment issues:
+
+1. Check Railway logs first
+2. Verify environment variables
+3. Test locally before deploying
+4. Review service startup sequence

README.md

@@ -99,15 +99,13 @@ A comprehensive financial analysis tool that provides stock data, news analysis,
   - News data via `gnews`
 - **AI Model**: mistral-small-3.2-24b-instruct via OpenRouter
 - **MCP Servers**: Modular servers for stock data and news
-- **Monitoring**: Real-time system resource monitoring
 
 ## Files
 
 - `Home.py`: Main Streamlit web application with ML predictions
-- `stock_data_server.py`: MCP server for stock data
-- `news_server.py`: MCP server for news data
-- `resource_monitor.py`: System resource monitoring
-- `pages/System_Monitor.py`: System monitoring dashboard
+- `Dockerfile`: Docker configuration for Railway deployment
+- `docker-compose.yml`: Local development setup
+- `railway.toml`: Railway deployment configuration
 - `requirements.txt`: Python dependencies
 - `pyproject.toml`: Project configuration
 
@@ -120,7 +118,7 @@ A comprehensive financial analysis tool that provides stock data, news analysis,
 - **scikit-learn**: Machine learning (Ridge Regression, StandardScaler, GridSearchCV)
 - **pandas**: Data manipulation
 - **numpy**: Numerical computations
-- **psutil**: System monitoring
+
 - **openai**: AI model integration
 - **fastmcp**: MCP server framework
 
@@ -165,7 +163,6 @@ A comprehensive financial analysis tool that provides stock data, news analysis,
 - Python 3.10 or higher
 - OpenRouter API key
 - Internet connection for real-time data
-- Optional: psutil for system monitoring features
 
 ## Disclaimer
 

mcp_config.json

@@ -0,0 +1,22 @@
+{
+  "servers": {
+    "news_server": {
+      "url": "http://localhost:8001/mcp",
+      "transport": "streamable_http"
+    },
+    "stock_server": {
+      "url": "http://localhost:8002/mcp", 
+      "transport": "streamable_http"
+    }
+  },
+  "railway": {
+    "news_server": {
+      "url": "http://localhost:$PORT+1/mcp",
+      "transport": "streamable_http"
+    },
+    "stock_server": {
+      "url": "http://localhost:$PORT+2/mcp",
+      "transport": "streamable_http"
+    }
+  }
+} 

news_server.py → mcp_news_server.py

@@ -4,9 +4,16 @@ from bs4 import BeautifulSoup
 import re
 
 # Initialize the MCP Server
+import os
+
+port = int(os.environ.get("PORT", "8002"))
+
 mcp = FastMCP(
     name="Financial News Server",
-    description="Provides tools and resources for fetching and analyzing financial news.",
+    description="Provides tools and resources for fetching and analyzing financial news with real-time updates via SSE.",
+    host="0.0.0.0",
+    port=port,
+    stateless_http=True,
 )
 
 
@@ -21,7 +28,7 @@ def preprocess_text(text):
 
 
 @mcp.tool()
-def get_latest_news(ticker: str) -> str:
+async def get_latest_news(ticker: str) -> str:
     """
     Fetches recent news headlines and descriptions for a specific stock ticker.
     Use this tool when a user asks for news, updates, recent events about a company or about the company's stock.
@@ -78,6 +85,9 @@ def summarize_news_sentiment(news_headlines: str) -> str:
 
 
 if __name__ == "__main__":
-    # Use stdio transport for development
-    print("News Server running!")
-    mcp.run(transport="stdio")
+    # Use streamable HTTP transport with MCP endpoint
+    print(f"News Server running on http://localhost:{port}")
+    print("MCP endpoint available at:")
+    print(f"- http://localhost:{port}/mcp")
+
+    mcp.run(transport="streamable-http")

stock_data_server.py → mcp_stock_server.py

@@ -1,14 +1,22 @@
 from mcp.server.fastmcp import FastMCP
 import yfinance as yf
 
+# Initialize the MCP Server
+import os
+
+port = int(os.environ.get("PORT", "8001"))
+
 mcp = FastMCP(
     name="Stock Market Data Server",
-    description="Provides tools for fetching historical stock prices and market data.",
+    description="Provides tools for fetching historical stock prices and market data with real-time updates via SSE.",
+    host="0.0.0.0",
+    port=port,
+    stateless_http=True,
 )
 
 
 @mcp.tool()
-def get_historical_stock_data(ticker: str) -> str:
+async def get_historical_stock_data(ticker: str) -> str:
     """
     Fetches recent historical stock data (Open, High, Low, Close, Volume) for a given stock ticker.
     The input must be a single, valid stock ticker symbol (e.g., 'TSLA').
@@ -22,8 +30,6 @@ def get_historical_stock_data(ticker: str) -> str:
         if hist_data.empty:
             return f"No stock data found for ticker {ticker}."
 
-        # Return the last 5 days of data as a clean string
-        # return f"Recent stock data for {ticker}:\n{hist_data.tail().to_string()}"
         return f"Recent stock data for {ticker}:\n{hist_data.to_string()}"
     except Exception as e:
         return f"An error occurred while fetching stock data: {e}"
@@ -41,8 +47,10 @@ def get_ohlc_definitions() -> str:
     """
 
 
-# Add this to the end of stock_data_server.py
 if __name__ == "__main__":
-    # Use stdio transport for development
-    print("Stock Data Server running!")
-    mcp.run(transport="stdio")
+    # Use streamable HTTP transport with MCP endpoint
+    print(f"Stock Data Server running on http://localhost:{port}")
+    print("MCP endpoint available at:")
+    print(f"- http://localhost:{port}/mcp")
+
+    mcp.run(transport="streamable-http")

pages/System_Monitor.py

@@ -1,162 +0,0 @@
-import streamlit as st
-
-try:
-    from resource_monitor import (
-        start_resource_monitoring,
-        get_resource_stats,
-        get_resource_summary,
-        export_resource_data,
-    )
-
-    RESOURCE_MONITORING_AVAILABLE = True
-except ImportError:
-    RESOURCE_MONITORING_AVAILABLE = False
-    st.warning("Resource monitoring not available. Install psutil: pip install psutil")
-
-
-def main():
-    st.set_page_config(page_title="System Monitor", page_icon="📊", layout="wide")
-
-    st.title("📊 System Resource Monitor")
-    st.markdown("Real-time monitoring of system resources and application metrics.")
-
-    # Initialize resource monitoring
-    if RESOURCE_MONITORING_AVAILABLE:
-        if "resource_monitoring_started" not in st.session_state:
-            start_resource_monitoring()
-            st.session_state.resource_monitoring_started = True
-
-        # Current stats with loading state
-        with st.spinner("📊 Loading resource statistics..."):
-            current_stats = get_resource_stats()
-
-        if "error" not in current_stats:
-            # System Metrics
-            st.subheader("🖥️ System Metrics")
-            col1, col2, col3, col4 = st.columns(4)
-
-            with col1:
-                st.metric("CPU Usage", f"{current_stats['cpu_percent']:.1f}%")
-                st.metric("Memory Usage", f"{current_stats['memory_percent']:.1f}%")
-
-            with col2:
-                st.metric("Memory (GB)", f"{current_stats['memory_gb']:.2f} GB")
-                st.metric("Disk Usage", f"{current_stats['disk_usage_percent']:.1f}%")
-
-            with col3:
-                st.metric("Network Sent", f"{current_stats['network_sent_mb']:.1f} MB")
-                st.metric("Network Recv", f"{current_stats['network_recv_mb']:.1f} MB")
-
-            with col4:
-                st.metric("Process Count", current_stats["process_count"])
-                st.metric("Uptime", f"{current_stats['uptime_seconds']/60:.1f} min")
-
-            # Application-specific metrics
-            st.subheader("📈 Application Metrics")
-            col1, col2, col3, col4 = st.columns(4)
-
-            with col1:
-                st.metric("YFinance Calls", current_stats["yfinance_calls"])
-
-            with col2:
-                st.metric(
-                    "Ridge Training Time",
-                    f"{current_stats['ridge_training_time']:.2f}s",
-                )
-
-            with col3:
-                st.metric("ML Predictions", current_stats.get("ml_predictions", 0))
-
-            with col4:
-                st.metric("Streamlit Requests", current_stats["streamlit_requests"])
-
-            # ML Model Information
-            st.subheader("🤖 Machine Learning Metrics")
-            col1, col2, col3 = st.columns(3)
-
-            with col1:
-                st.metric(
-                    "Model Type", current_stats.get("ml_model", "Ridge Regression")
-                )
-                st.metric("Features Used", current_stats.get("feature_count", 35))
-
-            with col2:
-                st.metric(
-                    "Technical Indicators", current_stats.get("feature_count", 35)
-                )
-                st.metric("Training Data", "5 years")
-
-            with col3:
-                st.metric("Prediction Period", "30 days")
-                st.metric("Model Accuracy", "80-95% R²")
-
-            # Summary statistics
-            summary_stats = get_resource_summary()
-            if summary_stats:
-                st.subheader("📋 Summary Statistics")
-                col1, col2 = st.columns(2)
-
-                with col1:
-                    st.write(
-                        f"**Average CPU Usage:** {summary_stats.get('avg_cpu_percent', 0):.1f}%"
-                    )
-                    st.write(
-                        f"**Max CPU Usage:** {summary_stats.get('max_cpu_percent', 0):.1f}%"
-                    )
-                    st.write(
-                        f"**Average Memory Usage:** {summary_stats.get('avg_memory_percent', 0):.1f}%"
-                    )
-                    st.write(
-                        f"**Max Memory Usage:** {summary_stats.get('max_memory_percent', 0):.1f}%"
-                    )
-
-                with col2:
-                    st.write(
-                        f"**Total Network Sent:** {summary_stats.get('total_network_sent_mb', 0):.1f} MB"
-                    )
-                    st.write(
-                        f"**Total Network Recv:** {summary_stats.get('total_network_recv_mb', 0):.1f} MB"
-                    )
-                    st.write(
-                        f"**Total Uptime:** {summary_stats.get('total_uptime_minutes', 0):.1f} minutes"
-                    )
-                    st.write(
-                        f"**Total YFinance Calls:** {summary_stats.get('yfinance_calls', 0)}"
-                    )
-
-            # ML Summary
-            if summary_stats:
-                st.subheader("🤖 ML Model Summary")
-                col1, col2 = st.columns(2)
-
-                with col1:
-                    st.write(
-                        f"**Total Ridge Training Time:** {summary_stats.get('ridge_training_time', 0):.2f}s"
-                    )
-                    st.write(
-                        f"**Total ML Predictions:** {summary_stats.get('ml_predictions', 0)}"
-                    )
-                    st.write(
-                        f"**Model Type:** {summary_stats.get('ml_model', 'Ridge Regression')}"
-                    )
-                    st.write(
-                        f"**Technical Indicators:** {summary_stats.get('technical_indicators', 35)}"
-                    )
-
-                with col2:
-                    st.write("**Features Include:**")
-                    st.write("• Moving Averages (SMA 10, 20, 50, 200)")
-                    st.write("• Momentum Indicators (RSI, MACD, Stochastic)")
-                    st.write("• Volatility Indicators (Bollinger Bands)")
-                    st.write("• Volume Analysis & Market Sentiment")
-
-        else:
-            st.error(f"Error getting resource stats: {current_stats['error']}")
-    else:
-        st.warning(
-            "Resource monitoring is not available. Please install psutil: pip install psutil"
-        )
-
-
-if __name__ == "__main__":
-    main()

pyproject.toml

@@ -3,17 +3,21 @@ name = "financial-agent"
 version = "0.1.0"
 description = "Add your description here"
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.12"
 dependencies = [
+    "aiohttp>=3.12.15",
     "beautifulsoup4>=4.13.4",
     "fastmcp>=2.10.6",
     "gnews>=0.4.1",
+    "holidays>=0.77",
+    "httpx>=0.28.1",
+    "langchain-groq>=0.3.6",
+    "langchain-mcp-adapters>=0.1.9",
+    "langgraph>=0.6.3",
     "mcp[cli]>=1.12.2",
     "openai>=1.97.1",
     "pandas>=2.3.1",
     "plotly>=5.17.0",
-    "prophet>=1.1.7",
-    "psutil>=7.0.0",
     "python-dotenv>=1.1.1",
     "sentence-transformers>=5.0.0",
     "streamlit>=1.28.0",

railway.toml

@@ -0,0 +1,16 @@
+[build]
+builder = "DOCKERFILE"
+dockerfilePath = "Dockerfile"
+
+[deploy]
+startCommand = "python start_services.py"
+healthcheckPath = "/_stcore/health"
+healthcheckTimeout = 300
+restartPolicyType = "ON_FAILURE"
+restartPolicyMaxRetries = 10
+
+[env]
+GROQ_API_KEY = ""
+MODEL = ""
+NEWS_SERVER_URL = "http://localhost:8001/mcp"
+STOCK_SERVER_URL = "http://localhost:8002/mcp" 

resource_monitor.py

@@ -1,386 +0,0 @@
-import psutil
-import time
-import threading
-import plotly.graph_objects as go
-from datetime import datetime
-import json
-import os
-import glob
-from typing import Dict
-
-
-class ResourceMonitor:
-    """Monitor system resources for the QueryStockAI."""
-
-    def __init__(self):
-        self.monitoring = False
-        self.monitor_thread = None
-        self.resource_data = {
-            "timestamps": [],
-            "cpu_percent": [],
-            "memory_percent": [],
-            "memory_mb": [],
-            "disk_usage_percent": [],
-            "network_sent_mb": [],
-            "network_recv_mb": [],
-            "process_count": [],
-            "yfinance_calls": 0,
-            "ridge_training_time": 0,  # Updated from prophet_training_time
-            "streamlit_requests": 0,
-            "ml_predictions": 0,  # New counter for ML predictions
-            "feature_count": 35,  # Number of technical indicators used
-        }
-        self.start_time = None
-        self.process = psutil.Process()
-
-    def start_monitoring(self):
-        """Start resource monitoring in a separate thread."""
-        if not self.monitoring:
-            self.monitoring = True
-            self.start_time = datetime.now()
-
-            # Clean up old files when starting monitoring
-            self.cleanup_old_files()
-
-            self.monitor_thread = threading.Thread(
-                target=self._monitor_loop, daemon=True
-            )
-            self.monitor_thread.start()
-            return True
-        return False
-
-    def stop_monitoring(self):
-        """Stop resource monitoring."""
-        self.monitoring = False
-        if self.monitor_thread:
-            self.monitor_thread.join(timeout=1)
-
-    def _monitor_loop(self):
-        """Main monitoring loop."""
-        while self.monitoring:
-            try:
-                # Get current timestamp
-                timestamp = datetime.now()
-
-                # CPU usage
-                cpu_percent = psutil.cpu_percent(interval=1)
-
-                # Memory usage
-                memory = psutil.virtual_memory()
-                memory_percent = memory.percent
-                memory_mb = memory.used / (1024 * 1024)  # Convert to MB
-
-                # Disk usage
-                disk = psutil.disk_usage("/")
-                disk_usage_percent = disk.percent
-
-                # Network usage
-                network = psutil.net_io_counters()
-                network_sent_mb = network.bytes_sent / (1024 * 1024)
-                network_recv_mb = network.bytes_recv / (1024 * 1024)
-
-                # Process count
-                process_count = len(psutil.pids())
-
-                # Store data
-                self.resource_data["timestamps"].append(timestamp)
-                self.resource_data["cpu_percent"].append(cpu_percent)
-                self.resource_data["memory_percent"].append(memory_percent)
-                self.resource_data["memory_mb"].append(memory_mb)
-                self.resource_data["disk_usage_percent"].append(disk_usage_percent)
-                self.resource_data["network_sent_mb"].append(network_sent_mb)
-                self.resource_data["network_recv_mb"].append(network_recv_mb)
-                self.resource_data["process_count"].append(process_count)
-
-                # Keep only last 1000 data points to prevent memory issues
-                max_points = 1000
-                if len(self.resource_data["timestamps"]) > max_points:
-                    for key in self.resource_data:
-                        if isinstance(self.resource_data[key], list):
-                            self.resource_data[key] = self.resource_data[key][
-                                -max_points:
-                            ]
-
-                time.sleep(2)  # Monitor every 2 seconds
-
-            except Exception as e:
-                print(f"Error in monitoring loop: {e}")
-                time.sleep(5)
-
-    def get_current_stats(self) -> Dict:
-        """Get current resource statistics."""
-        try:
-            memory = psutil.virtual_memory()
-            disk = psutil.disk_usage("/")
-            network = psutil.net_io_counters()
-
-            return {
-                "cpu_percent": psutil.cpu_percent(),
-                "memory_percent": memory.percent,
-                "memory_mb": memory.used / (1024 * 1024),
-                "memory_gb": memory.used / (1024 * 1024 * 1024),
-                "disk_usage_percent": disk.percent,
-                "disk_free_gb": disk.free / (1024 * 1024 * 1024),
-                "network_sent_mb": network.bytes_sent / (1024 * 1024),
-                "network_recv_mb": network.bytes_recv / (1024 * 1024),
-                "process_count": len(psutil.pids()),
-                "uptime_seconds": (
-                    (datetime.now() - self.start_time).total_seconds()
-                    if self.start_time
-                    else 0
-                ),
-                "yfinance_calls": self.resource_data["yfinance_calls"],
-                "ridge_training_time": self.resource_data[
-                    "ridge_training_time"
-                ],  # Updated
-                "streamlit_requests": self.resource_data["streamlit_requests"],
-                "ml_predictions": self.resource_data["ml_predictions"],  # New
-                "feature_count": self.resource_data["feature_count"],  # New
-            }
-        except Exception as e:
-            return {"error": str(e)}
-
-    def increment_yfinance_calls(self):
-        """Increment yfinance API call counter."""
-        self.resource_data["yfinance_calls"] += 1
-
-    def add_ridge_training_time(self, seconds: float):
-        """Add Ridge Regression training time."""
-        self.resource_data["ridge_training_time"] += seconds
-
-    def increment_streamlit_requests(self):
-        """Increment Streamlit request counter."""
-        self.resource_data["streamlit_requests"] += 1
-
-    def increment_ml_predictions(self):
-        """Increment ML prediction counter."""
-        self.resource_data["ml_predictions"] += 1
-
-    def create_resource_dashboard(self) -> go.Figure:
-        """Create a comprehensive resource dashboard."""
-        if not self.resource_data["timestamps"]:
-            return None
-
-        # Create subplots
-        fig = go.Figure()
-
-        # CPU Usage
-        fig.add_trace(
-            go.Scatter(
-                x=self.resource_data["timestamps"],
-                y=self.resource_data["cpu_percent"],
-                mode="lines",
-                name="CPU %",
-                line=dict(color="red", width=2),
-            )
-        )
-
-        # Memory Usage
-        fig.add_trace(
-            go.Scatter(
-                x=self.resource_data["timestamps"],
-                y=self.resource_data["memory_percent"],
-                mode="lines",
-                name="Memory %",
-                line=dict(color="blue", width=2),
-                yaxis="y2",
-            )
-        )
-
-        # Memory Usage in MB
-        fig.add_trace(
-            go.Scatter(
-                x=self.resource_data["timestamps"],
-                y=self.resource_data["memory_mb"],
-                mode="lines",
-                name="Memory (MB)",
-                line=dict(color="lightblue", width=2),
-                yaxis="y3",
-            )
-        )
-
-        # Network Usage
-        fig.add_trace(
-            go.Scatter(
-                x=self.resource_data["timestamps"],
-                y=self.resource_data["network_sent_mb"],
-                mode="lines",
-                name="Network Sent (MB)",
-                line=dict(color="green", width=2),
-                yaxis="y4",
-            )
-        )
-
-        fig.add_trace(
-            go.Scatter(
-                x=self.resource_data["timestamps"],
-                y=self.resource_data["network_recv_mb"],
-                mode="lines",
-                name="Network Recv (MB)",
-                line=dict(color="orange", width=2),
-                yaxis="y4",
-            )
-        )
-
-        # Update layout
-        fig.update_layout(
-            title="System Resource Usage - QueryStockAI with Ridge Regression",
-            xaxis_title="Time",
-            height=600,
-            hovermode="x unified",
-            legend=dict(
-                orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1
-            ),
-            yaxis=dict(title="CPU %", side="left"),
-            yaxis2=dict(title="Memory %", side="right", overlaying="y"),
-            yaxis3=dict(title="Memory (MB)", side="right", position=0.95),
-            yaxis4=dict(title="Network (MB)", side="right", position=0.9),
-        )
-
-        return fig
-
-    def get_summary_stats(self) -> Dict:
-        """Get summary statistics."""
-        if not self.resource_data["timestamps"]:
-            return {}
-
-        return {
-            "total_uptime_minutes": (
-                (datetime.now() - self.start_time).total_seconds() / 60
-                if self.start_time
-                else 0
-            ),
-            "avg_cpu_percent": sum(self.resource_data["cpu_percent"])
-            / len(self.resource_data["cpu_percent"]),
-            "max_cpu_percent": max(self.resource_data["cpu_percent"]),
-            "avg_memory_percent": sum(self.resource_data["memory_percent"])
-            / len(self.resource_data["memory_percent"]),
-            "max_memory_percent": max(self.resource_data["memory_percent"]),
-            "avg_memory_mb": sum(self.resource_data["memory_mb"])
-            / len(self.resource_data["memory_mb"]),
-            "max_memory_mb": max(self.resource_data["memory_mb"]),
-            "total_network_sent_mb": sum(self.resource_data["network_sent_mb"]),
-            "total_network_recv_mb": sum(self.resource_data["network_recv_mb"]),
-            "yfinance_calls": self.resource_data["yfinance_calls"],
-            "ridge_training_time": self.resource_data["ridge_training_time"],  # Updated
-            "streamlit_requests": self.resource_data["streamlit_requests"],
-            "ml_predictions": self.resource_data["ml_predictions"],  # New
-            "feature_count": self.resource_data["feature_count"],  # New
-            "ml_model": "Ridge Regression",  # New
-            "technical_indicators": self.resource_data["feature_count"],  # New
-        }
-
-    def export_data(self, filename: str = None):
-        """Export monitoring data to JSON file."""
-        if filename is None:
-            filename = (
-                f"resource_monitor_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
-            )
-
-        export_data = {
-            "summary_stats": self.get_summary_stats(),
-            "monitoring_data": {
-                "timestamps": [
-                    ts.isoformat() for ts in self.resource_data["timestamps"]
-                ],
-                "cpu_percent": self.resource_data["cpu_percent"],
-                "memory_percent": self.resource_data["memory_percent"],
-                "memory_mb": self.resource_data["memory_mb"],
-                "disk_usage_percent": self.resource_data["disk_usage_percent"],
-                "network_sent_mb": self.resource_data["network_sent_mb"],
-                "network_recv_mb": self.resource_data["network_recv_mb"],
-                "process_count": self.resource_data["process_count"],
-            },
-            "ml_metrics": {  # New section
-                "model_type": "Ridge Regression",
-                "feature_count": self.resource_data["feature_count"],
-                "training_time": self.resource_data["ridge_training_time"],
-                "predictions_made": self.resource_data["ml_predictions"],
-                "data_sources": ["yfinance", "technical_indicators"],
-            },
-        }
-
-        with open(filename, "w") as f:
-            json.dump(export_data, f, indent=2)
-
-        # Clean up old files after creating a new one
-        self.cleanup_old_files()
-
-        return filename
-
-    def cleanup_old_files(self, max_files: int = 10, max_age_days: int = 7):
-        """Clean up old JSON files to prevent disk space issues."""
-        try:
-            # Get all resource monitor JSON files
-            pattern = "resource_monitor_*.json"
-            files = glob.glob(pattern)
-
-            if len(files) <= max_files:
-                return  # No cleanup needed
-
-            # Sort files by modification time (oldest first)
-            files.sort(key=lambda x: os.path.getmtime(x))
-
-            # Calculate cutoff time for age-based cleanup
-            cutoff_time = time.time() - (max_age_days * 24 * 60 * 60)
-
-            files_to_delete = []
-
-            # Add files that are too old
-            for file in files:
-                if os.path.getmtime(file) < cutoff_time:
-                    files_to_delete.append(file)
-
-            # Add oldest files if we still have too many
-            remaining_files = [f for f in files if f not in files_to_delete]
-            if len(remaining_files) > max_files:
-                files_to_delete.extend(remaining_files[:-max_files])
-
-            # Delete the files
-            deleted_count = 0
-            for file in files_to_delete:
-                try:
-                    os.remove(file)
-                    deleted_count += 1
-                except Exception as e:
-                    print(f"Error deleting file {file}: {e}")
-
-            if deleted_count > 0:
-                print(f"Cleaned up {deleted_count} old resource monitor files")
-
-        except Exception as e:
-            print(f"Error during file cleanup: {e}")
-
-
-# Global monitor instance
-resource_monitor = ResourceMonitor()
-
-
-def start_resource_monitoring():
-    """Start resource monitoring."""
-    return resource_monitor.start_monitoring()
-
-
-def stop_resource_monitoring():
-    """Stop resource monitoring."""
-    resource_monitor.stop_monitoring()
-
-
-def get_resource_stats():
-    """Get current resource statistics."""
-    return resource_monitor.get_current_stats()
-
-
-def create_resource_dashboard():
-    """Create resource dashboard."""
-    return resource_monitor.create_resource_dashboard()
-
-
-def get_resource_summary():
-    """Get resource summary."""
-    return resource_monitor.get_summary_stats()
-
-
-def export_resource_data(filename=None):
-    """Export resource data."""
-    return resource_monitor.export_data(filename)

start_services.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""
+Startup script to run all services on Railway deployment.
+This script launches:
+1. Streamlit app on $PORT (main port)
+2. MCP Stock Server on $PORT + 1
+3. MCP News Server on $PORT + 2
+"""
+
+import os
+import sys
+import time
+import signal
+import subprocess
+import multiprocessing
+from pathlib import Path
+
+
+def get_port():
+    """Get the main port from Railway environment."""
+    port = os.environ.get("PORT", "8501")
+    return int(port)
+
+
+def run_streamlit():
+    """Run Streamlit app on main port."""
+    port = get_port()
+    cmd = [
+        sys.executable,
+        "-m",
+        "streamlit",
+        "run",
+        "Home.py",
+        "--server.port",
+        str(port),
+        "--server.address",
+        "0.0.0.0",
+        "--server.headless",
+        "true",
+        "--browser.gatherUsageStats",
+        "false",
+    ]
+    print(f"🚀 Starting Streamlit on port {port}")
+    subprocess.run(cmd, check=True)
+
+
+def run_stock_server():
+    """Run MCP Stock Server on port + 1."""
+    port = get_port() + 1
+    cmd = [sys.executable, "mcp_stock_server.py"]
+    print(f"📊 Starting MCP Stock Server on port {port}")
+    # Set the port environment variable for the stock server
+    env = os.environ.copy()
+    env["PORT"] = str(port)
+    subprocess.run(cmd, env=env, check=True)
+
+
+def run_news_server():
+    """Run MCP News Server on port + 2."""
+    port = get_port() + 2
+    cmd = [sys.executable, "mcp_news_server.py"]
+    print(f"📰 Starting MCP News Server on port {port}")
+    # Set the port environment variable for the news server
+    env = os.environ.copy()
+    env["PORT"] = str(port)
+    subprocess.run(cmd, env=env, check=True)
+
+
+def signal_handler(signum, frame):
+    """Handle shutdown signals gracefully."""
+    print("\n🛑 Received shutdown signal. Stopping all services...")
+    sys.exit(0)
+
+
+def main():
+    """Main function to start all services."""
+    # Set up signal handlers
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    print("🚀 Starting Financial Agent Services...")
+    print(f"📋 Configuration:")
+    print(f"   - Main Port: {get_port()}")
+    print(f"   - Stock Server Port: {get_port() + 1}")
+    print(f"   - News Server Port: {get_port() + 2}")
+
+    # Check if required files exist
+    required_files = ["Home.py", "mcp_stock_server.py", "mcp_news_server.py"]
+    for file in required_files:
+        if not Path(file).exists():
+            print(f"❌ Error: {file} not found!")
+            sys.exit(1)
+
+    # Update MCP server URLs in Home.py for Railway deployment
+    try:
+        print("🔄 Updating MCP server URLs...")
+        subprocess.run([sys.executable, "update_mcp_urls.py"], check=True)
+        print("✅ MCP server URLs updated successfully!")
+    except Exception as e:
+        print(f"⚠️ Warning: Could not update MCP URLs: {e}")
+        print("Continuing with default configuration...")
+
+    # Start all services in separate processes
+    processes = []
+
+    try:
+        # Start MCP servers first (they need to be ready before Streamlit)
+        print("🔄 Starting MCP servers...")
+
+        # Start stock server
+        stock_process = multiprocessing.Process(
+            target=run_stock_server, name="stock-server"
+        )
+        stock_process.start()
+        processes.append(stock_process)
+
+        # Start news server
+        news_process = multiprocessing.Process(
+            target=run_news_server, name="news-server"
+        )
+        news_process.start()
+        processes.append(news_process)
+
+        # Wait a bit for MCP servers to start
+        print("⏳ Waiting for MCP servers to initialize...")
+        time.sleep(5)
+
+        # Start Streamlit app
+        print("🔄 Starting Streamlit app...")
+        streamlit_process = multiprocessing.Process(
+            target=run_streamlit, name="streamlit"
+        )
+        streamlit_process.start()
+        processes.append(streamlit_process)
+
+        print("✅ All services started successfully!")
+        print(f"🌐 Streamlit app available at: http://localhost:{get_port()}")
+        print(f"📊 Stock server available at: http://localhost:{get_port() + 1}")
+        print(f"📰 News server available at: http://localhost:{get_port() + 2}")
+
+        # Optional: Run deployment test
+        if os.environ.get("RUN_DEPLOYMENT_TEST", "false").lower() == "true":
+            print("\n🧪 Running deployment test...")
+            try:
+                subprocess.run([sys.executable, "test_deployment.py"], check=True)
+                print("✅ Deployment test passed!")
+            except subprocess.CalledProcessError:
+                print("⚠️ Deployment test failed, but services may still be working...")
+
+        # Wait for all processes
+        for process in processes:
+            process.join()
+
+    except KeyboardInterrupt:
+        print("\n🛑 Shutting down services...")
+    except Exception as e:
+        print(f"❌ Error starting services: {e}")
+    finally:
+        # Terminate all processes
+        for process in processes:
+            if process.is_alive():
+                process.terminate()
+                process.join(timeout=5)
+                if process.is_alive():
+                    process.kill()
+        print("✅ All services stopped.")
+
+
+if __name__ == "__main__":
+    main()

terminal_client.py

@@ -1,454 +0,0 @@
-import os
-import asyncio
-import json
-from dotenv import load_dotenv
-from openai import OpenAI
-from mcp.client.session import ClientSession
-from mcp.client.stdio import stdio_client
-from mcp import StdioServerParameters, types
-import yfinance as yf
-
-# Load API key from.env file
-load_dotenv()
-
-# Check if API key exists
-api_key = os.getenv("OPENROUTER_API_KEY")
-model = os.getenv("MODEL")
-if not api_key:
-    print("❌ Error: OPENROUTER_API_KEY not found in .env file")
-    exit(1)
-if not model:
-    print("❌ Error: MODEL not found in .env file")
-    exit(1)
-
-# Configure the client to connect to OpenRouter
-client = OpenAI(
-    base_url="https://openrouter.ai/api/v1",
-    api_key=api_key,
-)
-
-# Global variable to store discovered tools
-discovered_tools = []
-
-
-def get_available_tickers():
-    """Hardcoded tickers for testing"""
-
-    # Fallback to 10 most popular tickers if Lookup fails
-    try:
-        print("Using fallback to 10 most popular tickers...")
-        popular_tickers = {}
-
-        # 10 most popular tickers
-        popular_ticker_list = [
-            "AAPL",
-            "MSFT",
-            "GOOGL",
-            "AMZN",
-            "TSLA",
-            "META",
-            "NVDA",
-            "BRK-B",
-            "JNJ",
-            "JPM",
-        ]
-
-        print(f"Loading {len(popular_ticker_list)} popular tickers...")
-
-        # Get company names for each ticker
-        for ticker in popular_ticker_list:
-            try:
-                ticker_obj = yf.Ticker(ticker)
-                info = ticker_obj.info
-
-                if info and (info.get("longName") or info.get("shortName")):
-                    company_name = info.get("longName", info.get("shortName", ticker))
-                    popular_tickers[ticker] = company_name
-
-            except Exception as e:
-                # Skip tickers that cause errors
-                continue
-
-        print(f"Successfully loaded {len(popular_tickers)} tickers")
-        return popular_tickers
-
-    except Exception as e:
-        print(f"Error fetching available tickers: {e}")
-        # Final fallback to basic tickers if there's an error
-        return {
-            "AAPL": "Apple Inc.",
-            "TSLA": "Tesla Inc.",
-            "MSFT": "Microsoft Corporation",
-            "GOOGL": "Alphabet Inc. (Google)",
-        }
-
-
-def search_ticker(ticker_symbol):
-    """Search for a ticker symbol and get its company name using yfinance."""
-    try:
-        ticker = yf.Ticker(ticker_symbol)
-        info = ticker.info
-        company_name = info.get("longName", info.get("shortName", ticker_symbol))
-        return company_name
-    except Exception as e:
-        return None
-
-
-async def get_news_data(ticker: str) -> str:
-    """Get news data by calling the news server via MCP."""
-    try:
-        # Set up MCP server parameters
-        server_params = StdioServerParameters(command="python", args=["news_server.py"])
-
-        # Connect to the MCP server
-        async with stdio_client(server_params) as (read, write):
-            async with ClientSession(read, write) as session:
-                # Initialize the session
-                await session.initialize()
-
-                # Call the get_latest_news tool
-                print(f"🔍 Calling MCP tool: get_latest_news with ticker: {ticker}")
-                try:
-                    result = await asyncio.wait_for(
-                        session.call_tool("get_latest_news", {"ticker": ticker}),
-                        timeout=30.0,  # 30 second timeout
-                    )
-                    print(f"🔍 MCP result type: {type(result)}")
-                    print(f"🔍 MCP result content: {result.content}")
-                except asyncio.TimeoutError:
-                    print("❌ MCP call timed out")
-                    return f"Timeout getting news for {ticker}"
-                except Exception as e:
-                    print(f"❌ MCP call error: {e}")
-                    return f"Error getting news for {ticker}: {e}"
-
-                # Parse the result properly
-                if result.content:
-                    for content in result.content:
-                        if isinstance(content, types.TextContent):
-                            return content.text
-
-                return f"No news data returned for {ticker}"
-
-    except Exception as e:
-        return f"Error getting news for {ticker}: {e}"
-
-
-async def get_stock_data(ticker: str) -> str:
-    """Get stock data by calling the stock server via MCP."""
-    try:
-        # Set up MCP server parameters
-        server_params = StdioServerParameters(
-            command="python", args=["stock_data_server.py"]
-        )
-
-        # Connect to the MCP server
-        async with stdio_client(server_params) as (read, write):
-            async with ClientSession(read, write) as session:
-                # Initialize the session
-                await session.initialize()
-
-                # Call the get_historical_stock_data tool
-                print(
-                    f"🔍 Calling MCP tool: get_historical_stock_data with ticker: {ticker}"
-                )
-                try:
-                    result = await asyncio.wait_for(
-                        session.call_tool(
-                            "get_historical_stock_data", {"ticker": ticker}
-                        ),
-                        timeout=30.0,  # 30 second timeout
-                    )
-                    print(f"🔍 MCP result type: {type(result)}")
-                    print(f"🔍 MCP result content: {result.content}")
-                except asyncio.TimeoutError:
-                    print("❌ MCP call timed out")
-                    return f"Timeout getting stock data for {ticker}"
-                except Exception as e:
-                    print(f"❌ MCP call error: {e}")
-                    return f"Error getting stock data for {ticker}: {e}"
-
-                # Parse the result properly
-                if result.content:
-                    for content in result.content:
-                        if isinstance(content, types.TextContent):
-                            return content.text
-
-                return f"No stock data returned for {ticker}"
-
-    except Exception as e:
-        return f"Error getting stock data for {ticker}: {e}"
-
-
-def initialize_tools():
-    """Initialize the available tools."""
-    global discovered_tools
-
-    discovered_tools = [
-        {
-            "type": "function",
-            "function": {
-                "name": "get_latest_news",
-                "description": "Fetches recent news headlines and descriptions for a specific stock ticker. Use this when user asks about news, updates, or recent events about a company.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "ticker": {
-                            "type": "string",
-                            "description": "The stock ticker symbol (e.g., 'AAPL', 'GOOG', 'TSLA'). Must be a valid stock symbol.",
-                        }
-                    },
-                    "required": ["ticker"],
-                },
-            },
-        },
-        {
-            "type": "function",
-            "function": {
-                "name": "get_historical_stock_data",
-                "description": "Fetches recent historical stock data (Open, High, Low, Close, Volume) for a given ticker. Use this when user asks about stock performance, price data, or market performance.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "ticker": {
-                            "type": "string",
-                            "description": "The stock ticker symbol (e.g., 'AAPL', 'TSLA', 'MSFT'). Must be a valid stock symbol.",
-                        }
-                    },
-                    "required": ["ticker"],
-                },
-            },
-        },
-    ]
-
-    print(f"✅ Initialized {len(discovered_tools)} tools")
-
-
-async def execute_tool_call(tool_call):
-    """Execute a tool call using MCP servers."""
-    try:
-        tool_name = tool_call.function.name
-        arguments = json.loads(tool_call.function.arguments)
-        ticker = arguments.get("ticker")
-
-        if tool_name == "get_latest_news":
-            return await get_news_data(ticker)
-        elif tool_name == "get_historical_stock_data":
-            return await get_stock_data(ticker)
-        else:
-            return f"Unknown tool: {tool_name}"
-    except json.JSONDecodeError:
-        return f"Error: Invalid tool arguments format"
-    except Exception as e:
-        return f"Error executing tool {tool_call.function.name}: {e}"
-
-
-# The master prompt that defines the agent's behavior
-system_prompt = """
-You are a financial assistant that provides comprehensive analysis based on real-time data. You MUST use tools to get data and then curate the information to answer the user's specific question.
-
-AVAILABLE TOOLS:
-- get_latest_news: Get recent news for a ticker
-- get_historical_stock_data: Get stock performance data for a ticker
-
-CRITICAL INSTRUCTIONS:
-1. You MUST call BOTH tools (get_latest_news AND get_historical_stock_data) for every query
-2. After getting both news and stock data, analyze and synthesize the information
-3. Answer the user's specific question based on the data you gathered
-4. Provide insights, trends, and recommendations based on the combined data
-5. Format your response clearly with sections for news, performance, and analysis
-
-EXAMPLE WORKFLOW:
-1. User asks: "Should I invest in AAPL?"
-2. You call: get_latest_news with {"ticker": "AAPL"}
-3. You call: get_historical_stock_data with {"ticker": "AAPL"}
-4. You analyze both datasets and provide investment advice based on news sentiment and stock performance
-
-You are FORBIDDEN from responding without calling both tools. Always call both tools first, then provide a curated analysis based on the user's question.
-"""
-
-
-async def run_agent(user_query):
-    print(f"\n🔍 User Query: {user_query}")
-
-    messages = [
-        {"role": "system", "content": system_prompt},
-        {"role": "user", "content": user_query},
-    ]
-
-    try:
-        # Get initial response from the model
-        print("🤖 Getting response from model...")
-        response = client.chat.completions.create(
-            model=model,
-            messages=messages,
-            tools=discovered_tools,
-            tool_choice="required",
-        )
-
-        if not response.choices or len(response.choices) == 0:
-            print("❌ Error: No response from model")
-            return
-
-        response_message = response.choices[0].message
-        print(f"📝 Response type: {type(response_message)}")
-        print(
-            f"🔧 Has tool calls: {hasattr(response_message, 'tool_calls') and response_message.tool_calls}"
-        )
-
-        # Truncate tool call IDs if they're too long
-        if hasattr(response_message, "tool_calls") and response_message.tool_calls:
-            for tool_call in response_message.tool_calls:
-                if len(tool_call.id) > 40:
-                    tool_call.id = tool_call.id[:40]
-
-        messages.append(response_message)
-
-        # Execute tool calls if any
-        if response_message.tool_calls:
-            print("\n🛠️  Executing Tool Calls ---")
-            for tool_call in response_message.tool_calls:
-                print(f"📞 Calling: {tool_call.function.name}")
-                print(f"📋 Arguments: {tool_call.function.arguments}")
-
-                # Execute the tool call
-                tool_result = await execute_tool_call(tool_call)
-                print(
-                    f"📊 Result: {tool_result[:200] if tool_result else 'No result'}..."
-                )  # Show first 200 chars
-
-                # Add tool result to messages
-                messages.append(
-                    {
-                        "role": "tool",
-                        "tool_call_id": tool_call.id[:40],  # Truncate to max 40 chars
-                        "content": tool_result if tool_result else "No data available",
-                    }
-                )
-
-            # Get final response from the model (using same model for consistency)
-            print("🤖 Getting final response from model...")
-            print(f"📝 Messages count: {len(messages)}")
-            final_response = client.chat.completions.create(
-                model="openai/gpt-4o-mini",  # Try a different model
-                messages=messages,
-            )
-
-            print("\n🤖 Final Agent Response ---")
-            if final_response.choices and len(final_response.choices) > 0:
-                final_content = final_response.choices[0].message.content
-                print(
-                    f"Final response length: {len(final_content) if final_content else 0}"
-                )
-                print(final_content if final_content else "Empty response")
-            else:
-                print("No response generated")
-            print("----------------------------")
-        else:
-            print("\n🤖 Agent Response ---")
-            print(response_message.content)
-            print("----------------------")
-
-    except Exception as e:
-        print(f"❌ Error: {e}")
-        print("Please try again with a different question.")
-
-
-async def main():
-    """Main function to run the connected agent interactively."""
-    try:
-        # Initialize tools
-        initialize_tools()
-
-        # Get available tickers
-        available_tickers = get_available_tickers()
-
-        print("=== QueryStockAI ===")
-        print("Select a stock ticker to analyze:")
-        print("Type 'quit' or 'exit' to stop the program.")
-        print("=" * 50)
-
-        while True:
-            # Show ticker menu
-            print("\n📊 Available Stocks:")
-            ticker_list = list(available_tickers.items())
-            for i, (ticker, name) in enumerate(ticker_list, 1):
-                print(f"  {i}. {ticker} ({name})")
-            print("  s. Search for custom ticker")
-            print("  q. Quit")
-
-            # Get user selection
-            selection = (
-                input("\n💬 Select a stock, search (s), or type 'quit': ")
-                .strip()
-                .lower()
-            )
-
-            # Check if user wants to exit
-            if selection in ["quit", "exit", "q"]:
-                print("👋 Goodbye!")
-                break
-
-            # Handle search option
-            if selection == "s":
-                custom_ticker = (
-                    input("Enter ticker symbol (e.g., AAPL): ").strip().upper()
-                )
-                if custom_ticker:
-                    company_name = search_ticker(custom_ticker)
-                    if company_name:
-                        print(f"✅ Found: {custom_ticker} - {company_name}")
-                        # Add to available tickers temporarily
-                        available_tickers[custom_ticker] = company_name
-                        selected_ticker = custom_ticker
-                    else:
-                        print(f"❌ Could not find ticker: {custom_ticker}")
-                        continue
-                else:
-                    print("❌ Please enter a valid ticker symbol.")
-                    continue
-            else:
-                # Check if selection is valid
-                try:
-                    selection_num = int(selection)
-                    if selection_num < 1 or selection_num > len(ticker_list):
-                        print(
-                            f"❌ Invalid selection. Please choose 1-{len(ticker_list)}, 's' for search, or 'quit'."
-                        )
-                        continue
-                    selected_ticker = ticker_list[selection_num - 1][0]
-                except ValueError:
-                    print(
-                        "❌ Invalid selection. Please enter a number, 's' for search, or 'quit'."
-                    )
-                    continue
-
-            print(f"\n📈 Selected: {selected_ticker}")
-
-            # Always fetch both news and stock data by default
-            print(f"\n📊 Fetching comprehensive data for {selected_ticker}...")
-
-            # Get user's specific question
-            user_question = input(
-                f"\n💬 What would you like to know about {selected_ticker}? (e.g., 'How is it performing?', 'What's the latest news?', 'Should I invest?'): "
-            ).strip()
-
-            if not user_question:
-                user_question = (
-                    f"How is {selected_ticker} performing and what's the latest news?"
-                )
-
-            # Construct the query to always fetch both data types
-            user_query = f"Based on the latest news and stock performance data for {selected_ticker}, {user_question}"
-
-            # Run the agent with the user's query
-            await run_agent(user_query)
-
-    except KeyboardInterrupt:
-        print("\n\n👋 Goodbye!")
-    except Exception as e:
-        print(f"❌ Error: {e}")
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

test_deployment.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+"""
+Test script to verify Railway deployment is working correctly.
+This script checks if all services are running on the expected ports.
+"""
+
+import os
+import time
+import requests
+import subprocess
+import sys
+
+
+def get_port():
+    """Get the main port from Railway environment."""
+    port = os.environ.get("PORT", "8501")
+    return int(port)
+
+
+def test_service(url, service_name, timeout=10):
+    """Test if a service is responding."""
+    try:
+        response = requests.get(url, timeout=timeout)
+        if response.status_code == 200:
+            print(f"✅ {service_name} is running at {url}")
+            return True
+        else:
+            print(f"❌ {service_name} returned status {response.status_code} at {url}")
+            return False
+    except requests.exceptions.RequestException as e:
+        print(f"❌ {service_name} is not responding at {url}: {e}")
+        return False
+
+
+def test_mcp_endpoint(url, service_name):
+    """Test MCP endpoint specifically."""
+    try:
+        response = requests.get(f"{url}/mcp", timeout=10)
+        if response.status_code == 200:
+            print(f"✅ {service_name} MCP endpoint is accessible at {url}/mcp")
+            return True
+        else:
+            print(
+                f"❌ {service_name} MCP endpoint returned status {response.status_code}"
+            )
+            return False
+    except requests.exceptions.RequestException as e:
+        print(f"❌ {service_name} MCP endpoint is not accessible: {e}")
+        return False
+
+
+def main():
+    """Main test function."""
+    port = get_port()
+
+    print("🧪 Testing Railway Deployment...")
+    print(f"📋 Configuration:")
+    print(f"   - Main Port: {port}")
+    print(f"   - Stock Server Port: {port + 1}")
+    print(f"   - News Server Port: {port + 2}")
+    print()
+
+    # Test services
+    services = [
+        (f"http://localhost:{port}", "Streamlit App"),
+        (f"http://localhost:{port + 1}", "Stock Server"),
+        (f"http://localhost:{port + 2}", "News Server"),
+    ]
+
+    results = []
+
+    for url, name in services:
+        result = test_service(url, name)
+        results.append((name, result))
+
+    print()
+    print("🔍 Testing MCP Endpoints...")
+
+    # Test MCP endpoints
+    mcp_results = []
+    mcp_services = [
+        (f"http://localhost:{port + 1}", "Stock Server"),
+        (f"http://localhost:{port + 2}", "News Server"),
+    ]
+
+    for url, name in mcp_services:
+        result = test_mcp_endpoint(url, name)
+        mcp_results.append((name, result))
+
+    print()
+    print("📊 Test Results Summary:")
+
+    all_passed = True
+    for name, result in results + mcp_results:
+        status = "✅ PASS" if result else "❌ FAIL"
+        print(f"   {name}: {status}")
+        if not result:
+            all_passed = False
+
+    print()
+    if all_passed:
+        print("🎉 All services are running correctly!")
+        print("🚀 Your Railway deployment is ready to use.")
+    else:
+        print("⚠️ Some services failed. Check the logs above for details.")
+        print("🔧 Try restarting the deployment or check Railway logs.")
+
+    return 0 if all_passed else 1
+
+
+if __name__ == "__main__":
+    # Wait a bit for services to start
+    print("⏳ Waiting for services to start...")
+    time.sleep(5)
+
+    exit_code = main()
+    sys.exit(exit_code)

update_mcp_urls.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+"""
+Script to update MCP server URLs for Railway deployment.
+This script modifies the MCP client configuration in Home.py to use the correct ports.
+"""
+
+import os
+import re
+
+
+def get_port():
+    """Get the main port from Railway environment."""
+    port = os.environ.get("PORT", "8501")
+    return int(port)
+
+
+def update_home_py():
+    """Update Home.py to use correct MCP server URLs for Railway deployment."""
+    port = get_port()
+
+    # Calculate the ports for MCP servers
+    stock_port = port + 1
+    news_port = port + 2
+
+    # Read the current Home.py file
+    with open("Home.py", "r", encoding="utf-8") as f:
+        content = f.read()
+
+    # Update the MCP client configuration
+    # Find the MultiServerMCPClient configuration
+    pattern = r'client = MultiServerMCPClient\(\s*\{\s*"news_server":\s*\{\s*"url":\s*"[^"]*",\s*"transport":\s*"[^"]*",?\s*\},\s*"stock_server":\s*\{\s*"url":\s*"[^"]*",\s*"transport":\s*"[^"]*",?\s*\},\s*\}\s*\)'
+
+    new_config = f"""client = MultiServerMCPClient(
+                {{
+                    "news_server": {{
+                        "url": "http://localhost:{news_port}/mcp",
+                        "transport": "streamable_http",
+                    }},
+                    "stock_server": {{
+                        "url": "http://localhost:{stock_port}/mcp",
+                        "transport": "streamable_http",
+                    }},
+                }}
+            )"""
+
+    # Replace the configuration
+    updated_content = re.sub(pattern, new_config, content, flags=re.DOTALL)
+
+    # Write the updated content back
+    with open("Home.py", "w", encoding="utf-8") as f:
+        f.write(updated_content)
+
+    print(f"✅ Updated Home.py with MCP server URLs:")
+    print(f"   - Stock server: http://localhost:{stock_port}/mcp")
+    print(f"   - News server: http://localhost:{news_port}/mcp")
+
+
+if __name__ == "__main__":
+    update_home_py()