Upload 6 files

app.py

@@ -0,0 +1,12 @@
+# app.py (for Hugging Face Spaces)
+"""
+Main entry point for Hugging Face Spaces
+This file is required by HF Spaces to run the Streamlit app
+"""
+
+import subprocess
+import sys
+
+# Run the frontend Streamlit app
+if __name__ == "__main__":
+    subprocess.run([sys.executable, "-m", "streamlit", "run", "frontend.py"])

arithmetic_server.py

@@ -0,0 +1,30 @@
+from mcp.server.fastmcp import FastMCP
+
+# Creates a server named "Arithmetic"
+mcp = FastMCP("Arithmetic")
+
+@mcp.tool()
+def add(a: int, b: int) -> int:
+    """Add two numbers"""
+    return a + b
+
+@mcp.tool()
+def multiply(a: int, b: int) -> int:
+    """Multiply two numbers"""
+    return a * b
+
+@mcp.tool()
+def minus(a: int, b: int) -> int:
+    """Subtract two numbers (a - b)"""
+    return a - b
+
+@mcp.tool()
+def divide(a: int, b: int) -> float:
+    """Divide two numbers (a / b). Returns a float. Raises ValueError on division by zero."""
+    if b == 0:
+        raise ValueError("Division by zero is not allowed.")
+    return a / b
+
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

backend.py

@@ -0,0 +1,255 @@
+# backend.py
+"""
+Backend module for MCP Agent
+Handles all the MCP server connections, LLM setup, and agent logic
+"""
+
+import os
+import re
+import asyncio
+from dotenv import load_dotenv
+from typing import Optional, Dict, List, Any
+
+################### --- Auth setup --- ###################
+##########################################################
+# load the details from .env, then test it and raise as Asserterror if false
+load_dotenv()
+HF = os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACEHUB_API_TOKEN")
+assert HF, "Set HF_TOKEN (or HUGGINGFACEHUB_API_TOKEN) in your environment/.env"
+
+# then all env set to the same token to avoid env error.
+os.environ["HF_TOKEN"] = HF
+os.environ["HUGGINGFACEHUB_API_TOKEN"] = HF
+
+# Login with HF token
+try:
+    from huggingface_hub import login
+    login(token=HF)
+except Exception:
+    pass
+
+# --- LangChain / MCP ---
+from langgraph.prebuilt import create_react_agent
+from langchain_mcp_adapters.client import MultiServerMCPClient
+from langchain_huggingface import HuggingFaceEndpoint, ChatHuggingFace
+from langchain_core.messages import HumanMessage
+
+# First choice, then free/tiny fallbacks
+CANDIDATE_MODELS = [
+    os.getenv("HF_MODEL_ID", "Qwen/Qwen2.5-7B-Instruct"),
+    "HuggingFaceTB/SmolLM3-3B-Instruct",
+    "Qwen/Qwen2.5-1.5B-Instruct",
+    "microsoft/Phi-3-mini-4k-instruct",
+]
+
+SYSTEM_PROMPT = (
+    "You are an AI assistant with tools.\n"
+    "- Use the arithmetic tools (`add`, `minus`, `multiply`, `divide`) for arithmetic or multi-step calculations.\n"
+    "- Use the stock tools (`get_stock_price`, `get_market_summary`, `get_company_news`) for financial/market queries.\n"
+    "- Otherwise, answer directly with your own knowledge.\n"
+    "Be concise and accurate. Only call tools when they clearly help."
+)
+
+################### --- ROUTER helpers --- ###################
+##############################################################
+
+# Detect stock/financial intent
+def is_stock_query(q: str) -> bool:
+    """Check if query is about stocks, markets, or financial data."""
+    stock_patterns = [
+        r"\b(stock|share|price|ticker|market|nasdaq|dow|s&p|spy|qqq)\b",
+        r"\b(AAPL|GOOGL|MSFT|TSLA|AMZN|META|NVDA|AMD)\b",  # Common tickers
+        r"\$[A-Z]{1,5}\b",  # $SYMBOL format
+        r"\b(trading|invest|portfolio|earnings|dividend)\b",
+        r"\b(bull|bear|rally|crash|volatility)\b",
+    ]
+    return any(re.search(pattern, q, re.I) for pattern in stock_patterns)
+
+# Extract ticker symbol from query
+def extract_ticker(q: str) -> str:
+    """Extract stock ticker from query."""
+    # Check for $SYMBOL format first
+    dollar_match = re.search(r"\$([A-Z]{1,5})\b", q, re.I)
+    if dollar_match:
+        return dollar_match.group(1).upper()
+    
+    # Check for common patterns like "price of AAPL" or "AAPL stock"
+    patterns = [
+        r"(?:price of|stock price of|quote for)\s+([A-Z]{1,5})\b",
+        r"\b([A-Z]{1,5})\s+(?:stock|share|price|quote)",
+        r"(?:what is|what's|get)\s+([A-Z]{1,5})\b",
+    ]
+    
+    for pattern in patterns:
+        match = re.search(pattern, q, re.I)
+        if match:
+            return match.group(1).upper()
+    
+    # Look for standalone uppercase tickers
+    words = q.split()
+    for word in words:
+        clean_word = word.strip(".,!?")
+        if 2 <= len(clean_word) <= 5 and clean_word.isupper():
+            return clean_word
+    
+    return None
+
+# Check if asking for market summary
+def wants_market_summary(q: str) -> bool:
+    """Check if user wants overall market summary."""
+    patterns = [
+        r"\bmarket\s+(?:summary|overview|today|status)\b",
+        r"\bhow(?:'s| is) the market\b",
+        r"\b(?:dow|nasdaq|s&p)\s+(?:today|now)\b",
+        r"\bmarket indices\b",
+    ]
+    return any(re.search(pattern, q, re.I) for pattern in patterns)
+
+# Check if asking for news
+def wants_news(q: str) -> bool:
+    """Check if user wants company news."""
+    return bool(re.search(r"\b(news|headline|announcement|update)\b", q, re.I))
+
+def build_tool_map(tools):
+    mp = {t.name: t for t in tools}
+    return mp
+
+def find_tool(name: str, tool_map: dict):
+    name = name.lower()
+    for k, t in tool_map.items():
+        kl = k.lower()
+        if kl == name or kl.endswith("/" + name):
+            return t
+    return None
+
+async def build_chat_llm_with_fallback():
+    """
+    Try each candidate model. For each:
+        - create HuggingFaceEndpoint + ChatHuggingFace
+        - do a tiny 'ping' with a proper LC message to trigger routing
+    On 402/Payment Required (or other errors), fall through to next.
+    """
+    last_err = None
+    for mid in CANDIDATE_MODELS:
+        try:
+            llm = HuggingFaceEndpoint(
+                repo_id=mid,
+                huggingfacehub_api_token=HF,
+                temperature=0.1,
+                max_new_tokens=256,  # Increased for better responses
+            )
+            model = ChatHuggingFace(llm=llm)
+            # PROBE with a valid message type
+            _ = await model.ainvoke([HumanMessage(content="ping")])
+            print(f"[LLM] Using: {mid}")
+            return model
+        except Exception as e:
+            msg = str(e)
+            if "402" in msg or "Payment Required" in msg:
+                print(f"[LLM] {mid} requires payment; trying next...")
+                last_err = e
+                continue
+            print(f"[LLM] {mid} error: {e}; trying next...")
+            last_err = e
+            continue
+    raise RuntimeError(f"Could not initialize any candidate model. Last error: {last_err}")
+
+# NEW: Class to manage the MCP Agent (moved from main function)
+class MCPAgent:
+    def __init__(self):
+        self.client = None
+        self.agent = None
+        self.tool_map = None
+        self.tools = None
+        self.model = None
+        self.initialized = False
+        
+    async def initialize(self):
+        """Initialize the MCP client and agent"""
+        if self.initialized:
+            return
+            
+        # Start the Stock server separately first: `python stockserver.py`
+        self.client = MultiServerMCPClient(
+            {
+                "arithmetic": {
+                    "command": "python",
+                    "args": ["arithmetic_server.py"],
+                    "transport": "stdio",
+                },
+                "stocks": {
+                    "url": "http://localhost:8000/mcp",
+                    "transport": "streamable_http",
+                },
+            }
+        )
+        
+        # 1. MCP client + tools
+        self.tools = await self.client.get_tools()
+        self.tool_map = build_tool_map(self.tools)
+        
+        # 2. Build LLM with auto-fallback
+        self.model = await build_chat_llm_with_fallback()
+        
+        # Build the ReAct agent with MCP tools
+        self.agent = create_react_agent(self.model, self.tools)
+        
+        self.initialized = True
+        return list(self.tool_map.keys())  # Return available tools
+    
+    async def process_message(self, user_text: str, history: List[Dict]) -> str:
+        """Process a single message with the agent"""
+        if not self.initialized:
+            await self.initialize()
+        
+        # Try direct stock tool routing first
+        if is_stock_query(user_text):
+            if wants_market_summary(user_text):
+                market_tool = find_tool("get_market_summary", self.tool_map)
+                if market_tool:
+                    return await market_tool.ainvoke({})
+            
+            elif wants_news(user_text):
+                ticker = extract_ticker(user_text)
+                if ticker:
+                    news_tool = find_tool("get_company_news", self.tool_map)
+                    if news_tool:
+                        return await news_tool.ainvoke({"symbol": ticker, "limit": 3})
+            
+            else:
+                ticker = extract_ticker(user_text)
+                if ticker:
+                    price_tool = find_tool("get_stock_price", self.tool_map)
+                    if price_tool:
+                        return await price_tool.ainvoke({"symbol": ticker})
+        
+        # Fall back to agent for everything else
+        messages = [{"role": "system", "content": SYSTEM_PROMPT}] + history + [
+            {"role": "user", "content": user_text}
+        ]
+        result = await self.agent.ainvoke({"messages": messages})
+        return result["messages"][-1].content
+    
+    async def cleanup(self):
+        """Clean up resources"""
+        if self.client:
+            close = getattr(self.client, "close", None)
+            if callable(close):
+                res = close()
+                if asyncio.iscoroutine(res):
+                    await res
+
+
+
+
+
+
+# NEW: Singleton instance for the agent
+_agent_instance = None
+
+def get_agent() -> MCPAgent:
+    """Get or create the singleton agent instance"""
+    global _agent_instance
+    if _agent_instance is None:
+        _agent_instance = MCPAgent()
+    return _agent_instance

frontend.py

@@ -0,0 +1,216 @@
+# frontend.py
+"""
+Streamlit frontend for MCP Agent
+Provides a chat interface for interacting with the MCP backend
+"""
+
+import streamlit as st
+import asyncio
+from backend import get_agent, MCPAgent
+import time
+
+# Page configuration
+st.set_page_config(
+    page_title="MCP Agent Chat",
+    page_icon="🤖",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for better chat appearance
+st.markdown("""
+<style>
+    .stChatMessage {
+        padding: 1rem;
+        border-radius: 0.5rem;
+        margin-bottom: 1rem;
+    }
+    .user-message {
+        background-color: #e3f2fd;
+    }
+    .assistant-message {
+        background-color: #f5f5f5;
+    }
+    .sidebar-info {
+        padding: 1rem;
+        background-color: #f0f2f6;
+        border-radius: 0.5rem;
+        margin-bottom: 1rem;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Initialize session state
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+    st.session_state.history = []  # For agent history
+    st.session_state.agent_initialized = False
+    st.session_state.available_tools = []
+    st.session_state.pending_query = None  # For example queries
+
+# Sidebar
+with st.sidebar:
+    st.title("🤖 MCP Agent")
+    st.markdown("---")
+    
+    # Status indicator
+    if st.session_state.agent_initialized:
+        st.success("✅ Agent Connected")
+        
+        # Show available tools
+        st.markdown("### 🛠️ Available Tools")
+        for tool in st.session_state.available_tools:
+            st.markdown(f"• `{tool}`")
+    else:
+        st.info("⏳ Agent Initializing...")
+    
+    st.markdown("---")
+    
+    # Example queries
+    st.markdown("### 💡 Example Queries")
+    example_queries = [
+        "What's the price of AAPL?",
+        "Show me the market summary",
+        "Get news about TSLA",
+        "Calculate 25 * 4",
+        "What's 100 divided by 7?",
+        "Add 456 and 789"
+    ]
+    
+    for query in example_queries:
+        if st.button(query, key=f"example_{query}"):
+            st.session_state.pending_query = query
+            st.rerun()
+    
+    st.markdown("---")
+    
+    # Clear chat button
+    if st.button("🗑️ Clear Chat", type="secondary"):
+        st.session_state.messages = []
+        st.session_state.history = []
+        st.rerun()
+    
+    # Info section
+    st.markdown("### ℹ️ About")
+    st.markdown("""
+    This chat interface connects to:
+    - **Math Server**: Basic arithmetic operations
+    - **Stock Server**: Real-time market data
+    
+    The agent uses LangChain and MCP to intelligently route your queries to the appropriate tools.
+    """)
+
+# Main chat interface
+st.title("💬 MCP Agent Chat")
+st.markdown("Ask me about stocks, math calculations, or general questions!")
+
+# Initialize agent asynchronously
+async def initialize_agent():
+    """Initialize the agent if not already done"""
+    if not st.session_state.agent_initialized:
+        agent = get_agent()
+        with st.spinner("🔧 Initializing MCP servers..."):
+            try:
+                tools = await agent.initialize()
+                st.session_state.available_tools = tools
+                st.session_state.agent_initialized = True
+                return True
+            except Exception as e:
+                st.error(f"Failed to initialize agent: {str(e)}")
+                st.info("Please make sure the stock server is running: `python stockserver.py`")
+                return False
+    return True
+
+# Process user message
+async def process_user_message(user_input: str):
+    """Process the user's message and get response from agent"""
+    agent = get_agent()
+    
+    # Add user message to history
+    st.session_state.history.append({"role": "user", "content": user_input})
+    
+    try:
+        # Get response from agent
+        response = await agent.process_message(user_input, st.session_state.history)
+        
+        # Add assistant response to history
+        st.session_state.history.append({"role": "assistant", "content": response})
+        
+        return response
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+# Display chat messages
+for message in st.session_state.messages:
+    with st.chat_message(message["role"]):
+        st.markdown(message["content"])
+
+# Process pending query from example buttons
+if st.session_state.pending_query:
+    query = st.session_state.pending_query
+    st.session_state.pending_query = None  # Clear it
+    
+    # Add to messages
+    st.session_state.messages.append({"role": "user", "content": query})
+    
+    # Process the query
+    async def process_example():
+        if not st.session_state.agent_initialized:
+            if not await initialize_agent():
+                return "Failed to initialize agent. Please check the servers."
+        return await process_user_message(query)
+    
+    # Get response
+    with st.spinner("Processing..."):
+        response = asyncio.run(process_example())
+    
+    # Add response to messages
+    st.session_state.messages.append({"role": "assistant", "content": response})
+    
+    # Rerun to display the new messages
+    st.rerun()
+
+# Chat input
+if prompt := st.chat_input("Type your message here..."):
+    # Add user message to chat
+    st.session_state.messages.append({"role": "user", "content": prompt})
+    
+    # Display user message
+    with st.chat_message("user"):
+        st.markdown(prompt)
+    
+    # Get and display assistant response
+    with st.chat_message("assistant"):
+        message_placeholder = st.empty()
+        
+        # Run async function
+        async def get_response():
+            # Initialize agent if needed
+            if not st.session_state.agent_initialized:
+                if not await initialize_agent():
+                    return "Failed to initialize agent. Please check the servers."
+            
+            # Process message
+            return await process_user_message(prompt)
+        
+        # Execute async function
+        with st.spinner("Thinking..."):
+            response = asyncio.run(get_response())
+        
+        message_placeholder.markdown(response)
+        st.session_state.messages.append({"role": "assistant", "content": response})
+
+# Initialize agent on first load
+if not st.session_state.agent_initialized:
+    asyncio.run(initialize_agent())
+
+# Footer
+st.markdown("---")
+st.markdown(
+    """
+    <div style='text-align: center; color: #666;'>
+    Powered by LangChain, MCP, and Hugging Face 🤗
+    </div>
+    """,
+    unsafe_allow_html=True
+)

requirements.txt

@@ -1,3 +1,13 @@
-altair
-pandas
-streamlit
+langchain-mcp-adapters==0.1.9
+mcp==1.12.3
+langgraph==0.6.3
+langchain-huggingface==0.3.1
+aiohttp=3.12.15
+
+
+streamlit==1.48.0
+python-dotenv
+huggingface-hub
+
+fastmcp
+asyncio

stock_server.py

@@ -0,0 +1,63 @@
+from mcp.server.fastmcp import FastMCP
+import aiohttp
+import json
+from typing import Optional
+
+mcp = FastMCP("StockMarket")
+
+@mcp.tool()
+async def get_stock_price(symbol: str) -> str:
+    """
+    Get current stock price and info for a given ticker symbol.
+    Uses Alpha Vantage free API (or Yahoo Finance fallback).
+    """
+    # Using a mock response for demo - replace with actual API call
+    # For real implementation, use yfinance or Alpha Vantage API
+    mock_prices = {
+        "AAPL": {"price": 195.89, "change": "+2.34", "percent": "+1.21%"},
+        "GOOGL": {"price": 142.57, "change": "-0.89", "percent": "-0.62%"},
+        "MSFT": {"price": 378.91, "change": "+5.12", "percent": "+1.37%"},
+        "TSLA": {"price": 238.45, "change": "-3.21", "percent": "-1.33%"},
+    }
+    
+    symbol = symbol.upper()
+    if symbol in mock_prices:
+        data = mock_prices[symbol]
+        return f"{symbol}: ${data['price']} ({data['change']}, {data['percent']})"
+    
+    # For production, uncomment and use real API:
+    # try:
+    #     import yfinance as yf
+    #     ticker = yf.Ticker(symbol)
+    #     info = ticker.info
+    #     price = info.get('currentPrice', info.get('regularMarketPrice', 'N/A'))
+    #     return f"{symbol}: ${price}"
+    # except:
+    #     return f"Could not fetch data for {symbol}"
+    
+    return f"Unknown symbol: {symbol}"
+
+@mcp.tool()
+async def get_market_summary() -> str:
+    """Get a summary of major market indices."""
+    # Mock data - replace with real API calls
+    return """Market Summary:
+    📊 S&P 500: 4,783.45 (+0.73%)
+    📈 NASDAQ: 15,123.68 (+1.18%)
+    📉 DOW: 37,863.80 (-0.31%)
+    💱 USD/EUR: 0.9234
+    🪙 Bitcoin: $43,521.00 (+2.4%)
+    🛢️ Oil (WTI): $73.41/barrel"""
+
+@mcp.tool()
+async def get_company_news(symbol: str, limit: int = 3) -> str:
+    """Get latest news headlines for a company."""
+    # Mock news - in production, use NewsAPI or similar
+    symbol = symbol.upper()
+    return f"""Latest news for {symbol}:
+    1. {symbol} announces Q4 earnings beat expectations
+    2. Analysts upgrade {symbol} to 'Buy' rating
+    3. {symbol} unveils new product line for 2025"""
+
+if __name__ == "__main__":
+    mcp.run(transport="streamable-http")