feat: langfuse

.env.example

@@ -1,3 +1,15 @@
 # Copy this file to .env and fill in your API keys
 GROQ_API_KEY=your_groq_api_key_here
-TAVILY_API_KEY=your_tavily_api_key_here
+TAVILY_API_KEY=your_tavily_api_key_here
+
+# Langfuse Configuration
+LANGFUSE_SECRET_KEY=sk-lf-...
+LANGFUSE_PUBLIC_KEY=pk-lf-...
+LANGFUSE_HOST=http://localhost:3000
+
+# Optional Langfuse Settings
+TELEMETRY_ENABLED=true
+LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES=false
+
+# Environment Mode (development/production)
+STREAMLIT_ENV=development

LANGFUSE_SETUP.md

@@ -0,0 +1,145 @@
+# Langfuse Monitoring Setup
+
+This guide helps you set up Langfuse monitoring for your LangGraph application to track LLM responses, costs, and performance.
+
+## 🚀 Quick Start
+
+### 1. Start Langfuse Services
+
+```bash
+# Start Langfuse database and server
+docker-compose up -d langfuse-db langfuse-server
+
+# Or use the setup script
+python setup_langfuse.py
+```
+
+### 2. Configure Langfuse
+
+1. Open http://localhost:3000 in your browser
+2. Create an account or sign in
+3. Create a new project (or use the default one)
+4. Go to **Settings** → **API Keys**
+5. Copy the **Secret Key** and **Public Key**
+
+### 3. Update Environment Variables
+
+Add to your `.env` file:
+
+```env
+LANGFUSE_SECRET_KEY=sk-lf-your-secret-key-here
+LANGFUSE_PUBLIC_KEY=pk-lf-your-public-key-here
+LANGFUSE_HOST=http://localhost:3000
+```
+
+### 4. Start the Application
+
+```bash
+# Start all services including your app
+docker-compose up --build
+
+# Or start just your app if Langfuse is already running
+docker-compose up langgraph-agenticai
+```
+
+## 📊 What Gets Monitored
+
+- **LLM Requests & Responses**: All interactions with Groq models
+- **Token Usage**: Input and output tokens for cost calculation
+- **Response Times**: Latency metrics for performance monitoring
+- **User Sessions**: Track user interactions across conversations
+- **Tool Usage**: Monitor MCP and other tool executions
+- **Error Tracking**: Capture and analyze failures
+
+## 🎯 Features
+
+### In-App Monitoring
+- ✅ Real-time monitoring status in sidebar
+- ✅ Direct link to Langfuse dashboard
+- ✅ Session tracking across conversations
+- ✅ Automatic cost tracking
+
+### Langfuse Dashboard
+- 📈 **Traces**: Detailed view of each conversation
+- 💰 **Costs**: Token usage and cost breakdown
+- ⚡ **Performance**: Response time analytics
+- 🔍 **Search**: Find specific interactions
+- 📊 **Analytics**: Usage patterns and trends
+
+## 🔧 Configuration Options
+
+### Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `LANGFUSE_SECRET_KEY` | Your Langfuse secret key | Required |
+| `LANGFUSE_PUBLIC_KEY` | Your Langfuse public key | Required |
+| `LANGFUSE_HOST` | Langfuse server URL | `http://localhost:3000` |
+| `TELEMETRY_ENABLED` | Enable Langfuse telemetry | `true` |
+
+### Docker Compose Services
+
+- **langfuse-db**: PostgreSQL database for Langfuse
+- **langfuse-server**: Langfuse web application
+- **langgraph-agenticai**: Your main application
+
+## 🛠️ Troubleshooting
+
+### Langfuse Not Starting
+
+```bash
+# Check service logs
+docker-compose logs langfuse-server
+docker-compose logs langfuse-db
+
+# Restart services
+docker-compose restart langfuse-server langfuse-db
+```
+
+### Connection Issues
+
+1. Verify environment variables are set correctly
+2. Check that Langfuse is accessible at http://localhost:3000
+3. Ensure API keys are valid and have proper permissions
+
+### Monitoring Not Working
+
+1. Check the sidebar for monitoring status
+2. Verify Langfuse credentials in `.env` file
+3. Look for error messages in the Streamlit app
+
+## 📚 Advanced Usage
+
+### Custom Traces
+
+```python
+from src.langgraphagenticai.monitoring.langfuse_integration import langfuse_manager
+
+# Create custom trace
+trace = langfuse_manager.create_trace(
+    name="custom_operation",
+    user_id="user123",
+    session_id="session456"
+)
+```
+
+### Cost Analysis
+
+Access detailed cost breakdowns in the Langfuse dashboard:
+1. Go to **Analytics** → **Usage**
+2. Filter by model, user, or time period
+3. Export data for further analysis
+
+## 🔗 Useful Links
+
+- [Langfuse Documentation](https://langfuse.com/docs)
+- [Langfuse GitHub](https://github.com/langfuse/langfuse)
+- [LangChain Integration](https://langfuse.com/docs/integrations/langchain)
+
+## 🆘 Support
+
+If you encounter issues:
+1. Check the troubleshooting section above
+2. Review Docker Compose logs
+3. Consult Langfuse documentation
+4. Open an issue in the project repository

docker-compose.app-only.yml

@@ -0,0 +1,29 @@
+version: '3.8'
+
+services:
+  # Main Application Only (without Langfuse)
+  langgraph-agenticai:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    container_name: langgraph-agenticai-app
+    ports:
+      - "8501:8501"
+    environment:
+      - GROQ_API_KEY=${GROQ_API_KEY}
+      - TAVILY_API_KEY=${TAVILY_API_KEY}
+      - STREAMLIT_ENV=production
+    volumes:
+      - ./src:/app/src
+      - ./app.py:/app/app.py
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "curl", "--fail", "http://localhost:8501/_stcore/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
+
+networks:
+  default:
+    driver: bridge

docker-compose.yml

@@ -1,6 +1,46 @@
 version: '3.8'
 
 services:
+  # Langfuse Database
+  langfuse-db:
+    image: postgres:15
+    container_name: langfuse-postgres
+    environment:
+      POSTGRES_DB: langfuse
+      POSTGRES_USER: langfuse
+      POSTGRES_PASSWORD: langfuse_password
+    volumes:
+      - langfuse_db_data:/var/lib/postgresql/data
+    networks:
+      - langgraph-network
+    restart: unless-stopped
+
+  # Langfuse Server
+  langfuse-server:
+    image: langfuse/langfuse:2
+    container_name: langfuse-server
+    depends_on:
+      - langfuse-db
+    ports:
+      - "3000:3000"
+    environment:
+      DATABASE_URL: postgresql://langfuse:langfuse_password@langfuse-db:5432/langfuse
+      NEXTAUTH_SECRET: mysecret
+      SALT: mysalt
+      NEXTAUTH_URL: http://localhost:3000
+      TELEMETRY_ENABLED: ${TELEMETRY_ENABLED:-true}
+      LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES: ${LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES:-false}
+    networks:
+      - langgraph-network
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "curl", "--fail", "http://localhost:3000/api/public/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 60s
+
+  # Main Application
   langgraph-agenticai:
     build:
       context: .
@@ -11,6 +51,10 @@ services:
     environment:
       - GROQ_API_KEY=${GROQ_API_KEY}
       - TAVILY_API_KEY=${TAVILY_API_KEY}
+      - LANGFUSE_SECRET_KEY=${LANGFUSE_SECRET_KEY:-}
+      - LANGFUSE_PUBLIC_KEY=${LANGFUSE_PUBLIC_KEY:-}
+      - LANGFUSE_HOST=${LANGFUSE_HOST:-http://langfuse-server:3000}
+      - STREAMLIT_ENV=${STREAMLIT_ENV:-development}
     volumes:
       - ./src:/app/src
       - ./app.py:/app/app.py
@@ -24,6 +68,9 @@ services:
     networks:
       - langgraph-network
 
+volumes:
+  langfuse_db_data:
+
 networks:
   langgraph-network:
     driver: bridge

requirements.txt

@@ -5,4 +5,7 @@ langchain_core==0.3.76
 langchain_groq==0.3.8
 langchain_openai==0.3.33
 faiss-cpu==1.12.0
-streamlit==1.49.1
+streamlit==1.49.1
+langchain-mcp-adapters
+mcp
+langfuse

setup_langfuse.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""
+Langfuse Setup Script
+Helps users set up Langfuse monitoring for the LangGraph application
+"""
+import os
+import json
+import requests
+import time
+import subprocess
+
+
+def wait_for_langfuse(host="http://localhost:3000", timeout=120):
+    """Wait for Langfuse to be ready"""
+    print(f"Waiting for Langfuse at {host}...")
+    
+    start_time = time.time()
+    while time.time() - start_time < timeout:
+        try:
+            response = requests.get(f"{host}/api/public/health", timeout=5)
+            if response.status_code == 200:
+                print("✅ Langfuse is ready!")
+                return True
+        except requests.exceptions.RequestException:
+            pass
+        
+        print("⏳ Waiting for Langfuse to start...")
+        time.sleep(5)
+    
+    print("❌ Timeout waiting for Langfuse")
+    return False
+
+
+def create_langfuse_project():
+    """Instructions for creating a Langfuse project"""
+    print("\n🚀 Setting up Langfuse monitoring...")
+    print("\n📋 Follow these steps:")
+    print("1. Open http://localhost:3000 in your browser")
+    print("2. Create an account or sign in")
+    print("3. Create a new project")
+    print("4. Go to Settings > API Keys")
+    print("5. Copy the Secret Key and Public Key")
+    print("6. Add them to your .env file:")
+    print("   LANGFUSE_SECRET_KEY=sk-lf-...")
+    print("   LANGFUSE_PUBLIC_KEY=pk-lf-...")
+    print("   LANGFUSE_HOST=http://localhost:3000")
+
+
+def main():
+    print("🔧 Langfuse Setup for LangGraph Application")
+    print("=" * 50)
+    
+    # Check if Docker Compose is available
+    try:
+        subprocess.run(["docker-compose", "--version"], 
+                      capture_output=True, check=True)
+        print("✅ Docker Compose is available")
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        print("❌ Docker Compose not found. Please install Docker Compose first.")
+        return
+    
+    # Start Langfuse services
+    print("\n🐳 Starting Langfuse services...")
+    try:
+        subprocess.run([
+            "docker-compose", "up", "-d", 
+            "langfuse-db", "langfuse-server"
+        ], check=True)
+        print("✅ Langfuse services started")
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Failed to start services: {e}")
+        return
+    
+    # Wait for Langfuse to be ready
+    if wait_for_langfuse():
+        create_langfuse_project()
+        
+        print("\n🎯 Next steps:")
+        print("1. Complete the Langfuse setup in your browser")
+        print("2. Update your .env file with the API keys")
+        print("3. Restart your application: docker-compose up --build")
+        print("4. Your LLM calls will now be monitored in Langfuse!")
+        
+        print(f"\n📊 Langfuse Dashboard: http://localhost:3000")
+    else:
+        print("❌ Failed to start Langfuse. Check Docker logs:")
+        print("docker-compose logs langfuse-server")
+
+
+if __name__ == "__main__":
+    main()

src/langgraphagenticai/graph/graph_builder.py

@@ -4,7 +4,9 @@ from langchain_core.prompts import ChatPromptTemplate
 from src.langgraphagenticai.state.state import State
 from src.langgraphagenticai.nodes.basic_chatbot_node import BasicChatbotNode
 from src.langgraphagenticai.nodes.chatbot_with_tool_node import ChatbotWithToolNode
+from src.langgraphagenticai.nodes.mcp_chatbot_node import MCPChatbotNode
 from src.langgraphagenticai.tools.search_tool import get_tools, create_tool_node
+from src.langgraphagenticai.tools.mcp_tools import create_mcp_tools_from_config
 import datetime
 
 
@@ -45,7 +47,35 @@ class GraphBuilder:
 
         return graph_builder
 
-    def setup_graph(self, usecase: str):
+    def mcp_chatbot_build_graph(self, mcp_config: dict):
+        """Build graph for MCP chatbot with MCP tools"""
+        graph_builder = StateGraph(State)
+
+        # Create MCP tools from configuration
+        mcp_tools = create_mcp_tools_from_config(mcp_config)
+        
+        if not mcp_tools:
+            raise ValueError("No MCP tools could be created from the configuration")
+
+        # Create tool node
+        tool_node = ToolNode(tools=mcp_tools)
+
+        # Create MCP chatbot node
+        mcp_chatbot_node_obj = MCPChatbotNode(self.llm)
+        chatbot_node = mcp_chatbot_node_obj.create_chatbot(tools=mcp_tools)
+
+        # Add nodes
+        graph_builder.add_node("chatbot", chatbot_node)
+        graph_builder.add_node("tools", tool_node)
+
+        # Define edges
+        graph_builder.add_edge(START, "chatbot")
+        graph_builder.add_conditional_edges("chatbot", tools_condition)
+        graph_builder.add_edge("tools", "chatbot")
+
+        return graph_builder
+
+    def setup_graph(self, usecase: str, **kwargs):
         if usecase == "Basic Chatbot":
             graph_builder = self.basic_chatbot_build_graph()
         elif usecase == "Chatbot with Tool":
@@ -54,6 +84,11 @@ class GraphBuilder:
             graph_builder = (
                 self.chatbot_with_tools_build_graph()
             )  # AI News also uses tools
+        elif usecase == "MCP Chatbot":
+            mcp_config = kwargs.get("mcp_config")
+            if not mcp_config:
+                raise ValueError("MCP configuration is required for MCP Chatbot")
+            graph_builder = self.mcp_chatbot_build_graph(mcp_config)
         else:
             raise ValueError(f"Unknown usecase: {usecase}")
 

src/langgraphagenticai/llms/groqllm.py

@@ -1,6 +1,7 @@
 import os
 import streamlit as st
 from langchain_groq import ChatGroq
+from src.langgraphagenticai.monitoring.langfuse_integration import create_monitored_llm, get_langfuse_callbacks
 
 
 class GroqLLM:
@@ -16,8 +17,24 @@ class GroqLLM:
                 st.error("Please enter the GROQ API key and select a model")
                 return None
 
-            llm = ChatGroq(api_key=groq_api_key, model=selected_groq_model)
-            return llm
+            # Create base LLM first (without monitoring)
+            llm = ChatGroq(
+                api_key=groq_api_key, 
+                model=selected_groq_model
+            )
+            
+            # Try to add monitoring, but don't fail if it doesn't work
+            try:
+                callbacks = get_langfuse_callbacks()
+                if callbacks:
+                    llm.callbacks = callbacks
+                
+                # Wrap with Langfuse monitoring
+                monitored_llm = create_monitored_llm(llm)
+                return monitored_llm
+            except Exception:
+                # If monitoring fails, return the base LLM
+                return llm
         except Exception as e:
             st.error(f"Error initializing ChatGroq: {str(e)}")
             print(str(e))

src/langgraphagenticai/main.py

@@ -5,6 +5,11 @@ from src.langgraphagenticai.ui.streamlitui.loadui import LoadStreamlitUI
 from src.langgraphagenticai.llms.groqllm import GroqLLM
 from src.langgraphagenticai.graph.graph_builder import GraphBuilder
 from src.langgraphagenticai.ui.streamlitui.display_result import DisplayResultStremlit
+# Import monitoring - but don't fail if it's not available
+try:
+    from src.langgraphagenticai.monitoring.langfuse_integration import langfuse_manager
+except ImportError:
+    langfuse_manager = None
 
 
 # Main function START
@@ -53,7 +58,15 @@ def load_langgraph_agenticai_app():
             graph_builder = GraphBuilder(model)
 
             try:
-                graph = graph_builder.setup_graph(usecase=usecase)
+                # Pass MCP config if it's an MCP usecase
+                if usecase == "MCP Chatbot":
+                    mcp_config = user_input.get("mcp_config")
+                    if not mcp_config:
+                        st.error("MCP configuration is required for MCP Chatbot")
+                        return
+                    graph = graph_builder.setup_graph(usecase=usecase, mcp_config=mcp_config)
+                else:
+                    graph = graph_builder.setup_graph(usecase=usecase)
                 DisplayResultStremlit(
                     usecase, graph, user_message
                 ).display_result_on_ui()

src/langgraphagenticai/mcp/__init__.py

@@ -0,0 +1 @@
+# MCP Integration Module

src/langgraphagenticai/mcp/mcp_client.py

@@ -0,0 +1,120 @@
+"""
+MCP Client Manager
+Handles connections to MCP servers and tool management
+"""
+import asyncio
+import subprocess
+from typing import Dict, List, Any, Optional
+import streamlit as st
+from langchain_mcp_adapters import MCPToolkit
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+from .mcp_config import MCPConfig
+
+
+class MCPClientManager:
+    def __init__(self):
+        self.config = MCPConfig()
+        self.active_sessions: Dict[str, ClientSession] = {}
+        self.toolkits: Dict[str, MCPToolkit] = {}
+
+    async def connect_to_server(self, server_name: str, server_config: Dict[str, Any]) -> Optional[MCPToolkit]:
+        """Connect to an MCP server and return its toolkit"""
+        try:
+            # Create server parameters
+            server_params = StdioServerParameters(
+                command=server_config["command"],
+                args=server_config.get("args", []),
+                env=server_config.get("env", {})
+            )
+            
+            # Create stdio client
+            stdio_transport = await stdio_client(server_params)
+            
+            # Create session
+            session = ClientSession(stdio_transport[0], stdio_transport[1])
+            
+            # Initialize session
+            await session.initialize()
+            
+            # Store session
+            self.active_sessions[server_name] = session
+            
+            # Create toolkit
+            toolkit = MCPToolkit(session=session)
+            self.toolkits[server_name] = toolkit
+            
+            st.success(f"✅ Connected to MCP server: {server_name}")
+            return toolkit
+            
+        except Exception as e:
+            st.error(f"❌ Failed to connect to MCP server {server_name}: {e}")
+            return None
+
+    async def connect_all_servers(self) -> Dict[str, MCPToolkit]:
+        """Connect to all enabled MCP servers"""
+        enabled_servers = self.config.get_enabled_servers()
+        connected_toolkits = {}
+        
+        for server_name, server_config in enabled_servers.items():
+            toolkit = await self.connect_to_server(server_name, server_config)
+            if toolkit:
+                connected_toolkits[server_name] = toolkit
+        
+        return connected_toolkits
+
+    def get_all_tools(self) -> List[Any]:
+        """Get all tools from all connected MCP servers"""
+        all_tools = []
+        
+        for server_name, toolkit in self.toolkits.items():
+            try:
+                server_config = self.config.get_server_config(server_name)
+                disabled_tools = server_config.get("disabledTools", [])
+                
+                # Get tools from toolkit
+                tools = toolkit.get_tools()
+                
+                # Filter out disabled tools
+                enabled_tools = [
+                    tool for tool in tools 
+                    if tool.name not in disabled_tools
+                ]
+                
+                all_tools.extend(enabled_tools)
+                st.info(f"📦 Loaded {len(enabled_tools)} tools from {server_name}")
+                
+            except Exception as e:
+                st.warning(f"⚠️ Error getting tools from {server_name}: {e}")
+        
+        return all_tools
+
+    async def disconnect_all(self):
+        """Disconnect from all MCP servers"""
+        for server_name, session in self.active_sessions.items():
+            try:
+                await session.close()
+                st.info(f"🔌 Disconnected from {server_name}")
+            except Exception as e:
+                st.warning(f"⚠️ Error disconnecting from {server_name}: {e}")
+        
+        self.active_sessions.clear()
+        self.toolkits.clear()
+
+    def is_server_available(self, server_name: str) -> bool:
+        """Check if a server is available and responding"""
+        server_config = self.config.get_server_config(server_name)
+        if not server_config:
+            return False
+        
+        try:
+            # Try to run the command to see if it's available
+            result = subprocess.run(
+                [server_config["command"], "--help"],
+                capture_output=True,
+                timeout=5
+            )
+            return result.returncode == 0
+        except Exception:
+            return False

src/langgraphagenticai/mcp/mcp_config.py

@@ -0,0 +1,85 @@
+"""
+MCP Configuration Management
+Handles loading and managing MCP server configurations
+"""
+
+import json
+import os
+from typing import Dict, List, Any, Optional
+import streamlit as st
+
+
+class MCPConfig:
+    def __init__(self):
+        self.workspace_config_path = ".kiro/settings/mcp.json"
+        self.user_config_path = os.path.expanduser("~/.kiro/settings/mcp.json")
+        self.config = self._load_config()
+
+    def _load_config(self) -> Dict[str, Any]:
+        """Load MCP configuration from workspace and user level configs"""
+        config = {"mcpServers": {}}
+
+        # Load user-level config first
+        user_config = self._load_config_file(self.user_config_path)
+        if user_config and "mcpServers" in user_config:
+            config["mcpServers"].update(user_config["mcpServers"])
+
+        # Load workspace-level config (takes precedence)
+        workspace_config = self._load_config_file(self.workspace_config_path)
+        if workspace_config and "mcpServers" in workspace_config:
+            config["mcpServers"].update(workspace_config["mcpServers"])
+
+        return config
+
+    def _load_config_file(self, file_path: str) -> Optional[Dict[str, Any]]:
+        """Load a single MCP config file"""
+        try:
+            if os.path.exists(file_path):
+                with open(file_path, "r") as f:
+                    return json.load(f)
+        except Exception as e:
+            st.warning(f"Error loading MCP config from {file_path}: {e}")
+        return None
+
+    def get_enabled_servers(self) -> Dict[str, Dict[str, Any]]:
+        """Get all enabled MCP servers"""
+        enabled_servers = {}
+        for server_name, server_config in self.config.get("mcpServers", {}).items():
+            if not server_config.get("disabled", False):
+                enabled_servers[server_name] = server_config
+        return enabled_servers
+
+    def get_server_config(self, server_name: str) -> Optional[Dict[str, Any]]:
+        """Get configuration for a specific server"""
+        return self.config.get("mcpServers", {}).get(server_name)
+
+    def create_default_config(self):
+        """Create a default MCP configuration file"""
+        default_config = {
+            "mcpServers": {
+                "filesystem": {
+                    "command": "uvx",
+                    "args": ["mcp-server-filesystem", "/tmp"],
+                    "disabled": False,
+                    "autoApprove": [],
+                    "disabledTools": [],
+                },
+                "brave-search": {
+                    "command": "uvx",
+                    "args": ["mcp-server-brave-search"],
+                    "env": {"BRAVE_API_KEY": "your_brave_api_key_here"},
+                    "disabled": True,
+                    "autoApprove": [],
+                    "disabledTools": [],
+                },
+            }
+        }
+
+        # Create directory if it doesn't exist
+        os.makedirs(os.path.dirname(self.workspace_config_path), exist_ok=True)
+
+        # Write default config
+        with open(self.workspace_config_path, "w") as f:
+            json.dump(default_config, f, indent=2)
+
+        return default_config

src/langgraphagenticai/monitoring/__init__.py

@@ -0,0 +1 @@
+# Monitoring and Analytics Module

src/langgraphagenticai/monitoring/dashboard.py

@@ -0,0 +1,96 @@
+"""
+Monitoring Dashboard Component
+Shows LLM usage statistics and costs in Streamlit
+"""
+import streamlit as st
+import os
+from typing import Dict, Any, List
+from datetime import datetime, timedelta
+from .langfuse_integration import langfuse_manager
+
+
+def show_monitoring_dashboard():
+    """Display monitoring dashboard in Streamlit sidebar"""
+    try:
+        if not langfuse_manager.is_enabled():
+            return
+        
+        with st.sidebar:
+            st.subheader("📊 LLM Monitoring")
+            
+            # Dashboard link
+            dashboard_url = langfuse_manager.get_dashboard_url()
+            st.markdown(f"[📈 Open Langfuse Dashboard]({dashboard_url})")
+            
+            # Quick stats (if available)
+            try:
+                # Note: This would require additional Langfuse API calls
+                # For now, we'll show basic info
+                st.metric("Status", "🟢 Active")
+                st.metric("Session", st.session_state.get("session_id", "N/A"))
+                
+            except Exception:
+                # Silently fail if stats can't be loaded
+                pass
+                
+    except Exception:
+        # Dashboard should never break the main app
+        pass
+
+
+def create_session_id() -> str:
+    """Create a unique session ID for tracking"""
+    if "session_id" not in st.session_state:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        st.session_state.session_id = f"session_{timestamp}"
+    
+    return st.session_state.session_id
+
+
+def log_user_interaction(usecase: str, user_message: str, response: str):
+    """Log user interaction for monitoring - fails silently if monitoring unavailable"""
+    try:
+        if not langfuse_manager.is_enabled():
+            return
+        
+        session_id = create_session_id()
+        
+        # Create trace for this interaction
+        trace = langfuse_manager.create_trace(
+            name=f"chat_interaction_{usecase}",
+            session_id=session_id,
+            user_id="streamlit_user",
+            metadata={
+                "usecase": usecase,
+                "timestamp": datetime.now().isoformat()
+            }
+        )
+        
+        if trace:
+            # Log the generation
+            langfuse_manager.log_generation(
+                trace_id=trace.id,
+                model="groq_llm",
+                input_text=user_message,
+                output_text=response,
+                metadata={
+                    "usecase": usecase,
+                    "session_id": session_id
+                }
+            )
+            
+    except Exception:
+        # Silently fail - logging should never break the app
+        pass
+
+
+def show_cost_tracking():
+    """Show cost tracking information"""
+    try:
+        if not langfuse_manager.is_enabled():
+            return
+        
+        st.info("💰 Cost tracking is enabled via Langfuse. View detailed costs in the dashboard.")
+    except Exception:
+        # Silently fail if cost tracking info can't be shown
+        pass

src/langgraphagenticai/monitoring/langfuse_integration.py

@@ -0,0 +1,146 @@
+"""
+Langfuse Integration for LLM Monitoring and Cost Tracking
+"""
+import os
+from typing import Optional, Dict, Any
+import streamlit as st
+from langfuse import Langfuse
+from langfuse.langchain import CallbackHandler
+from langchain.callbacks.base import BaseCallbackHandler
+
+
+class LangfuseManager:
+    """Manages Langfuse connection and monitoring"""
+    
+    def __init__(self):
+        self.langfuse = None
+        self.callback_handler = None
+        self._initialize_langfuse()
+    
+    def _initialize_langfuse(self):
+        """Initialize Langfuse client with graceful fallback"""
+        try:
+            secret_key = os.getenv("LANGFUSE_SECRET_KEY")
+            public_key = os.getenv("LANGFUSE_PUBLIC_KEY")
+            host = os.getenv("LANGFUSE_HOST", "http://localhost:3000")
+            
+            if not secret_key or not public_key:
+                # Silently disable monitoring if keys are not provided
+                return
+            
+            # Initialize Langfuse with timeout
+            self.langfuse = Langfuse(
+                secret_key=secret_key,
+                public_key=public_key,
+                host=host,
+                timeout=5  # 5 second timeout
+            )
+            
+            # Create callback handler for LangChain integration
+            self.callback_handler = CallbackHandler(
+                secret_key=secret_key,
+                public_key=public_key,
+                host=host,
+                timeout=5
+            )
+            
+            # Test connection with timeout
+            try:
+                self.langfuse.auth_check()
+                # Only show success message if in development mode
+                if os.getenv("STREAMLIT_ENV") != "production":
+                    st.success("✅ Langfuse monitoring enabled")
+            except Exception as auth_error:
+                # Connection test failed, disable monitoring
+                self.langfuse = None
+                self.callback_handler = None
+                if os.getenv("STREAMLIT_ENV") != "production":
+                    st.warning(f"⚠️ Langfuse connection failed: {auth_error}. Monitoring disabled.")
+                
+        except Exception as e:
+            # Any initialization error should not break the app
+            self.langfuse = None
+            self.callback_handler = None
+            # Only log in development mode
+            if os.getenv("STREAMLIT_ENV") != "production":
+                st.info("ℹ️ Langfuse monitoring not available")
+    
+    def get_callback_handler(self) -> Optional[BaseCallbackHandler]:
+        """Get the Langfuse callback handler for LangChain"""
+        return self.callback_handler
+    
+    def is_enabled(self) -> bool:
+        """Check if Langfuse monitoring is enabled"""
+        return self.langfuse is not None and self.callback_handler is not None
+    
+    def create_trace(self, name: str, user_id: Optional[str] = None, 
+                    session_id: Optional[str] = None, **kwargs) -> Optional[Any]:
+        """Create a new trace for monitoring"""
+        if not self.langfuse:
+            return None
+            
+        try:
+            return self.langfuse.trace(
+                name=name,
+                user_id=user_id,
+                session_id=session_id,
+                **kwargs
+            )
+        except Exception:
+            # Silently fail - monitoring should never break the app
+            return None
+    
+    def log_generation(self, trace_id: str, model: str, input_text: str, 
+                      output_text: str, **kwargs):
+        """Log a generation event"""
+        if not self.langfuse:
+            return
+            
+        try:
+            self.langfuse.generation(
+                trace_id=trace_id,
+                name="llm_generation",
+                model=model,
+                input=input_text,
+                output=output_text,
+                **kwargs
+            )
+        except Exception:
+            # Silently fail - monitoring should never break the app
+            pass
+    
+    def get_dashboard_url(self) -> str:
+        """Get the Langfuse dashboard URL"""
+        host = os.getenv("LANGFUSE_HOST", "http://localhost:3000")
+        return f"{host}/project/default"
+
+
+# Global instance
+langfuse_manager = LangfuseManager()
+
+
+def get_langfuse_callbacks():
+    """Get Langfuse callbacks for LangChain integration"""
+    if langfuse_manager.is_enabled():
+        return [langfuse_manager.get_callback_handler()]
+    return []
+
+
+def create_monitored_llm(llm, session_id: Optional[str] = None):
+    """Wrap an LLM with Langfuse monitoring - gracefully falls back if monitoring unavailable"""
+    try:
+        if not langfuse_manager.is_enabled():
+            return llm
+        
+        # Add Langfuse callback to the LLM
+        callbacks = get_langfuse_callbacks()
+        if callbacks:
+            # Create a new LLM instance with callbacks
+            llm_with_callbacks = llm.__class__(**llm.__dict__)
+            llm_with_callbacks.callbacks = callbacks
+            return llm_with_callbacks
+        
+        return llm
+    except Exception:
+        # If anything goes wrong with monitoring, return original LLM
+        return llm

src/langgraphagenticai/nodes/mcp_chatbot_node.py

@@ -0,0 +1,28 @@
+"""
+MCP Chatbot Node
+Handles chatbot logic with MCP tools integration
+"""
+from src.langgraphagenticai.state.state import State
+from typing import List, Any
+
+
+class MCPChatbotNode:
+    """
+    Chatbot logic enhanced with MCP tools integration
+    """
+    def __init__(self, model):
+        self.llm = model
+
+    def create_chatbot(self, tools: List[Any]):
+        """
+        Returns a chatbot node function with MCP tools
+        """
+        llm_with_tools = self.llm.bind_tools(tools)
+
+        def chatbot_node(state: State):
+            """
+            Chatbot logic for processing the input state and returning a response
+            """
+            return {"messages": [llm_with_tools.invoke(state["messages"])]}
+
+        return chatbot_node

src/langgraphagenticai/tools/mcp_tools.py

@@ -0,0 +1,141 @@
+"""
+MCP Tools Integration
+Handles MCP server connections and tool creation for LangGraph
+"""
+import json
+import asyncio
+import subprocess
+from typing import Dict, List, Any, Optional
+import streamlit as st
+from langchain.tools import BaseTool
+from pydantic import BaseModel, Field
+import tempfile
+import os
+
+
+class MCPTool(BaseTool):
+    """A LangChain tool that wraps MCP functionality"""
+    name: str = Field(...)
+    description: str = Field(...)
+    mcp_command: str = Field(...)
+    mcp_args: List[str] = Field(default_factory=list)
+    mcp_env: Dict[str, str] = Field(default_factory=dict)
+    
+    def _run(self, query: str) -> str:
+        """Execute the MCP tool"""
+        try:
+            # Set up environment
+            env = os.environ.copy()
+            env.update(self.mcp_env)
+            
+            # Create a simple input for the MCP server
+            input_data = {
+                "method": "tools/call",
+                "params": {
+                    "name": self.name,
+                    "arguments": {"query": query}
+                }
+            }
+            
+            # Run the MCP server command
+            result = subprocess.run(
+                [self.mcp_command] + self.mcp_args,
+                input=json.dumps(input_data),
+                capture_output=True,
+                text=True,
+                env=env,
+                timeout=30
+            )
+            
+            if result.returncode == 0:
+                return result.stdout
+            else:
+                return f"Error: {result.stderr}"
+                
+        except Exception as e:
+            return f"Error executing MCP tool: {str(e)}"
+
+
+def create_mcp_tools_from_config(mcp_config: Dict[str, Any]) -> List[MCPTool]:
+    """Create MCP tools from configuration"""
+    tools = []
+    
+    try:
+        mcp_servers = mcp_config.get("mcpServers", {})
+        
+        for server_name, server_config in mcp_servers.items():
+            if server_config.get("disabled", False):
+                continue
+                
+            # Create a generic tool for each MCP server
+            tool = MCPTool(
+                name=f"mcp_{server_name}",
+                description=f"MCP tool for {server_name} server - can handle various queries and operations",
+                mcp_command=server_config.get("command", "uvx"),
+                mcp_args=server_config.get("args", []),
+                mcp_env=server_config.get("env", {})
+            )
+            tools.append(tool)
+            
+    except Exception as e:
+        st.error(f"Error creating MCP tools: {e}")
+    
+    return tools
+
+
+def validate_mcp_config(config_text: str) -> Optional[Dict[str, Any]]:
+    """Validate MCP configuration JSON"""
+    try:
+        config = json.loads(config_text)
+        
+        # Basic validation
+        if "mcpServers" not in config:
+            st.error("MCP config must contain 'mcpServers' key")
+            return None
+            
+        # Validate each server config
+        for server_name, server_config in config["mcpServers"].items():
+            if "command" not in server_config:
+                st.error(f"Server '{server_name}' must have 'command' field")
+                return None
+                
+        return config
+        
+    except json.JSONDecodeError as e:
+        st.error(f"Invalid JSON: {e}")
+        return None
+    except Exception as e:
+        st.error(f"Error validating config: {e}")
+        return None
+
+
+def get_sample_mcp_config() -> str:
+    """Get a sample MCP configuration"""
+    return json.dumps({
+        "mcpServers": {
+            "filesystem": {
+                "command": "uvx",
+                "args": ["mcp-server-filesystem", "/tmp"],
+                "disabled": False,
+                "autoApprove": [],
+                "disabledTools": []
+            },
+            "brave-search": {
+                "command": "uvx",
+                "args": ["mcp-server-brave-search"],
+                "env": {
+                    "BRAVE_API_KEY": "your_brave_api_key_here"
+                },
+                "disabled": True,
+                "autoApprove": [],
+                "disabledTools": []
+            },
+            "sqlite": {
+                "command": "uvx",
+                "args": ["mcp-server-sqlite", "--db-path", "/tmp/test.db"],
+                "disabled": False,
+                "autoApprove": [],
+                "disabledTools": []
+            }
+        }
+    }, indent=2)

src/langgraphagenticai/ui/streamlitui/display_result.py

@@ -1,6 +1,7 @@
 import streamlit as st
 from langchain_core.messages import HumanMessage, AIMessage, ToolMessage
 import json
+from src.langgraphagenticai.monitoring.dashboard import log_user_interaction, show_cost_tracking
 
 class DisplayResultStremlit:
     def __init__(self, usecase, graph, user_message):
@@ -21,8 +22,18 @@ class DisplayResultStremlit:
                         st.write(user_message)
                     with st.chat_message("assisstant"):
                         st.write(value["messages"].content)
+                        
+                        # Log interaction for monitoring - fail silently if monitoring unavailable
+                        try:
+                            log_user_interaction(
+                                usecase=usecase,
+                                user_message=user_message,
+                                response=value["messages"].content
+                            )
+                        except Exception:
+                            pass
 
-        elif usecase == "Chatbot with Tool" or usecase == "AI News":
+        elif usecase == "Chatbot with Tool" or usecase == "AI News" or usecase == "MCP Chatbot":
             # Prepare state and invoke the graph
             initial_state = {"messages": [HumanMessage(content=user_message)]}
             
@@ -41,15 +52,38 @@ class DisplayResultStremlit:
                         for message in messages:
                             if isinstance(message, ToolMessage):
                                 with st.chat_message("assistant"):
-                                    st.write("🔍 **Tool Search Results:**")
+                                    if usecase == "MCP Chatbot":
+                                        st.write("🔧 **MCP Tool Results:**")
+                                    else:
+                                        st.write("🔍 **Tool Search Results:**")
                                     st.write(message.content)
                             elif isinstance(message, AIMessage):
                                 if message.tool_calls:
                                     with st.chat_message("assistant"):
-                                        st.write("🔧 **Calling search tool...**")
+                                        if usecase == "MCP Chatbot":
+                                            st.write("🚀 **Calling MCP tool...**")
+                                        else:
+                                            st.write("🔧 **Calling search tool...**")
                                         for tool_call in message.tool_calls:
-                                            st.write(f"Searching for: {tool_call['args'].get('query', 'N/A')}")
+                                            st.write(f"Tool: {tool_call.get('name', 'Unknown')}")
+                                            st.write(f"Query: {tool_call['args'].get('query', 'N/A')}")
                                 else:
                                     with st.chat_message("assistant"):
                                         st.write(message.content)
+                                        
+                                        # Log interaction for monitoring - fail silently if monitoring unavailable
+                                        try:
+                                            log_user_interaction(
+                                                usecase=usecase,
+                                                user_message=user_message,
+                                                response=message.content
+                                            )
+                                        except Exception:
+                                            pass
+            
+            # Show cost tracking info - fail silently if monitoring unavailable
+            try:
+                show_cost_tracking()
+            except Exception:
+                pass
                 

src/langgraphagenticai/ui/streamlitui/loadui.py

@@ -42,6 +42,21 @@ class LoadStreamlitUI:
         
 
         with st.sidebar:
+            # Langfuse monitoring status - fail silently if monitoring unavailable
+            try:
+                from src.langgraphagenticai.monitoring.langfuse_integration import langfuse_manager
+                if langfuse_manager.is_enabled():
+                    st.success("📊 Langfuse Monitoring: ON")
+                    dashboard_url = langfuse_manager.get_dashboard_url()
+                    st.markdown(f"[📈 View Dashboard]({dashboard_url})")
+                else:
+                    st.info("📊 Langfuse Monitoring: OFF")
+            except Exception:
+                # If monitoring status can't be determined, don't show anything
+                pass
+            
+            st.divider()
+            
             # Get options from config
             llm_options = self.config.get_llm_options()
             usecase_options = self.config.get_usecase_options()
@@ -88,6 +103,46 @@ class LoadStreamlitUI:
                     else :
                         st.session_state.IsFetchButtonClicked = False
             
+            elif self.user_controls["selected_usecase"] == "MCP Chatbot":
+                st.subheader("🔧 MCP Configuration")
+                
+                # Sample config button
+                if st.button("📋 Load Sample Config"):
+                    from src.langgraphagenticai.tools.mcp_tools import get_sample_mcp_config
+                    st.session_state.mcp_config_text = get_sample_mcp_config()
+                
+                # MCP Config input
+                mcp_config_text = st.text_area(
+                    "MCP Configuration JSON:",
+                    value=st.session_state.get("mcp_config_text", ""),
+                    height=300,
+                    help="Paste your MCP server configuration JSON here"
+                )
+                
+                if mcp_config_text:
+                    st.session_state.mcp_config_text = mcp_config_text
+                    
+                    # Validate config
+                    from src.langgraphagenticai.tools.mcp_tools import validate_mcp_config
+                    validated_config = validate_mcp_config(mcp_config_text)
+                    
+                    if validated_config:
+                        self.user_controls["mcp_config"] = validated_config
+                        st.success("✅ MCP configuration is valid!")
+                        
+                        # Show configured servers
+                        servers = validated_config.get("mcpServers", {})
+                        enabled_servers = [name for name, config in servers.items() if not config.get("disabled", False)]
+                        
+                        if enabled_servers:
+                            st.info(f"🚀 Enabled MCP servers: {', '.join(enabled_servers)}")
+                        else:
+                            st.warning("⚠️ No enabled MCP servers found in configuration")
+                    else:
+                        st.error("❌ Invalid MCP configuration")
+                else:
+                    st.info("💡 Please provide MCP configuration to use MCP tools")
+            
             if "state" not in st.session_state:
                 st.session_state.state = self.initialize_session()
 

src/langgraphagenticai/ui/uiconfigfile.ini

@@ -1,5 +1,5 @@
 [DEFAULT]
 PAGE_TITLE = Langgraph: Build Stateful Agentic AI graph
 LLM_OPTIONS = Groq
-USECASE_OPTIONS = Basic Chatbot, Chatbot with Tool, AI News
+USECASE_OPTIONS = Basic Chatbot, Chatbot with Tool, AI News, MCP Chatbot
 GROQ_MODEL_OPTIONS = openai/gpt-oss-120b, meta-llama/llama-guard-4-12b, llama-3.3-70b-versatile, openai/gpt-oss-20b