faet: guradrails

.env.example

@@ -12,4 +12,7 @@ TELEMETRY_ENABLED=true
 LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES=false
 
 # Environment Mode (development/production)
-STREAMLIT_ENV=development
+STREAMLIT_ENV=development
+
+# Guardrails Configuration
+GUARDRAILS_ENABLED=true

GUARDRAILS_SETUP.md

@@ -0,0 +1,229 @@
+# Guardrails AI Integration
+
+This guide explains how Guardrails AI is integrated into your LangGraph application to provide safety, validation, and quality control for LLM interactions.
+
+## 🛡️ What is Guardrails AI?
+
+Guardrails AI is a Python framework that adds safety rails to LLM applications by:
+- Validating inputs and outputs
+- Detecting toxic/harmful content
+- Ensuring output quality and structure
+- Preventing sensitive topic discussions
+- Adding content moderation
+
+## 🚀 Features Implemented
+
+### 1. Input Validation
+- **Toxic Language Detection**: Prevents harmful input from reaching the LLM
+- **Profanity Filtering**: Blocks inappropriate language
+- **Length Validation**: Ensures inputs are within reasonable limits (1-2000 chars)
+
+### 2. Output Quality Control
+- **Content Length**: Validates response length (10-5000 chars)
+- **Reading Time**: Ensures responses are appropriately sized (1-300 seconds reading time)
+- **Quality Assurance**: Maintains response quality standards
+
+### 3. Content Moderation
+- **Sensitive Topics**: Detects and prevents discussions of harmful topics
+- **Safety Filtering**: Blocks violence, hate speech, harassment content
+- **Threshold-based Detection**: Configurable sensitivity levels
+
+### 4. Structured Output Validation
+- **Schema Validation**: Ensures outputs match expected formats
+- **Type Safety**: Validates data types and structures
+- **Confidence Scoring**: Adds confidence metrics to responses
+
+## 🔧 Configuration
+
+### Environment Variables
+
+```env
+# Enable/disable Guardrails
+GUARDRAILS_ENABLED=true
+
+# Environment mode affects error display
+STREAMLIT_ENV=development
+```
+
+### Guard Types
+
+The application uses different guards for different scenarios:
+
+1. **Input Safety Guard**: Validates user inputs
+2. **Output Quality Guard**: Ensures response quality
+3. **Content Moderation Guard**: Filters harmful content
+4. **Structured Output Guard**: Validates response format
+
+## 📋 Usage
+
+### Automatic Protection
+
+Guardrails are automatically applied to:
+- All user inputs before processing
+- All LLM outputs before display
+- Tool interactions and responses
+- MCP server communications
+
+### Safety Warnings
+
+When content is filtered, users see friendly warnings:
+- 🛡️ **Input Safety**: Input was modified for safety
+- 🛡️ **Output Safety**: Response was filtered for safety
+
+### Fallback Behavior
+
+If validation fails:
+- **Input**: Safe alternative message is used
+- **Output**: Filtered safe response is provided
+- **Errors**: Application continues without breaking
+
+## 🎯 Use Case Specific Guards
+
+### Basic Chatbot
+- Input safety validation
+- Output quality control
+- Basic content moderation
+
+### Tool-Enabled Chatbots (MCP, Search)
+- Enhanced content moderation
+- Tool output validation
+- Structured response validation
+
+### AI News
+- News content appropriateness
+- Source validation
+- Information accuracy checks
+
+## 🔍 Monitoring Integration
+
+Guardrails works seamlessly with Langfuse monitoring:
+- Validation events are logged
+- Safety metrics are tracked
+- Guard performance is monitored
+- Compliance reports available
+
+## 🛠️ Customization
+
+### Adding Custom Guards
+
+```python
+from guardrails import Guard
+from guardrails.validators import ValidLength
+
+# Create custom guard
+custom_guard = Guard().use(
+    ValidLength(min=5, max=100),
+    # Add more validators
+)
+
+# Add to configuration
+guardrails_config.guards["custom"] = custom_guard
+```
+
+### Adjusting Thresholds
+
+```python
+# Modify sensitivity in guardrails_config.py
+ToxicLanguage(threshold=0.8)  # Higher = less sensitive
+SensitiveTopics(threshold=0.7)  # Lower = more sensitive
+```
+
+## 📊 Safety Dashboard
+
+### Status Indicators
+- 🛡️ **Guardrails: ON/OFF** - Shows protection status
+- **Active Guards**: Number of active validation rules
+- **Safety Metrics**: Validation statistics
+
+### Real-time Feedback
+- Input validation warnings
+- Output filtering notifications
+- Safety compliance indicators
+
+## 🚨 Troubleshooting
+
+### Guardrails Not Working
+
+1. **Check Environment Variable**:
+   ```bash
+   echo $GUARDRAILS_ENABLED
+   ```
+
+2. **Verify Installation**:
+   ```bash
+   pip list | grep guardrails
+   ```
+
+3. **Check Logs**:
+   - Look for Guardrails initialization messages
+   - Check for validation warnings in UI
+
+### Performance Issues
+
+1. **Disable Specific Guards**:
+   ```python
+   # In guardrails_config.py
+   # Comment out heavy validators
+   ```
+
+2. **Adjust Thresholds**:
+   ```python
+   # Increase thresholds for better performance
+   ToxicLanguage(threshold=0.9)
+   ```
+
+### False Positives
+
+1. **Review Validation Rules**:
+   - Check sensitive topics list
+   - Adjust toxicity thresholds
+   - Modify content filters
+
+2. **Whitelist Content**:
+   ```python
+   # Add exceptions for specific use cases
+   ```
+
+## 🔒 Security Benefits
+
+### Input Protection
+- Prevents prompt injection attacks
+- Blocks malicious content
+- Validates input formats
+
+### Output Safety
+- Ensures appropriate responses
+- Prevents harmful content generation
+- Maintains quality standards
+
+### Compliance
+- Meets safety guidelines
+- Supports content policies
+- Enables audit trails
+
+## 📈 Performance Impact
+
+### Minimal Overhead
+- Lightweight validation
+- Async processing where possible
+- Fail-safe fallbacks
+
+### Optimization
+- Cached validation results
+- Efficient rule processing
+- Smart threshold management
+
+## 🔗 Resources
+
+- [Guardrails AI Documentation](https://docs.guardrailsai.com/)
+- [Guardrails Hub](https://hub.guardrailsai.com/)
+- [GitHub Repository](https://github.com/guardrails-ai/guardrails)
+- [Community Examples](https://github.com/guardrails-ai/guardrails/tree/main/examples)
+
+## 🆘 Support
+
+For issues with Guardrails integration:
+1. Check the troubleshooting section
+2. Review environment configuration
+3. Consult Guardrails documentation
+4. Open an issue in the project repository

README.md

@@ -12,7 +12,4 @@ short_description: agenticai
 license: mit
 ---
 
-### END TO END AGENTIC AI APPLICATION
-
-- Add support for memory, tools and MCP in it
-- Add guardrail and lanfuse support
+### END TO END AGENTIC AI APPLICATION

docker-compose.app-only.yml

@@ -13,6 +13,7 @@ services:
       - GROQ_API_KEY=${GROQ_API_KEY}
       - TAVILY_API_KEY=${TAVILY_API_KEY}
       - STREAMLIT_ENV=production
+      - GUARDRAILS_ENABLED=${GUARDRAILS_ENABLED:-true}
     volumes:
       - ./src:/app/src
       - ./app.py:/app/app.py

docker-compose.yml

@@ -55,6 +55,7 @@ services:
       - LANGFUSE_PUBLIC_KEY=${LANGFUSE_PUBLIC_KEY:-}
       - LANGFUSE_HOST=${LANGFUSE_HOST:-http://langfuse-server:3000}
       - STREAMLIT_ENV=${STREAMLIT_ENV:-development}
+      - GUARDRAILS_ENABLED=${GUARDRAILS_ENABLED:-true}
     volumes:
       - ./src:/app/src
       - ./app.py:/app/app.py

requirements.txt

@@ -8,4 +8,6 @@ faiss-cpu==1.12.0
 streamlit==1.49.1
 langchain-mcp-adapters
 mcp
-langfuse
+langfuse
+guardrails-ai==0.5.10
+pydantic==2.5.0

src/langgraphagenticai/guardrails/__init__.py

@@ -0,0 +1 @@
+# Guardrails AI Integration Module

src/langgraphagenticai/guardrails/guardrails_config.py

@@ -0,0 +1,105 @@
+"""
+Guardrails Configuration and Management
+Handles safety and validation for LLM inputs and outputs
+"""
+import os
+from typing import Dict, Any, Optional, List
+import streamlit as st
+from guardrails import Guard
+from guardrails.hub import ToxicLanguage, ProfanityFree, ReadingTime, SensitiveTopics
+from guardrails.validators import ValidLength, ValidChoices
+from pydantic import BaseModel, Field
+
+
+class GuardrailsConfig:
+    """Configuration for Guardrails AI safety measures"""
+    
+    def __init__(self):
+        self.enabled = os.getenv("GUARDRAILS_ENABLED", "true").lower() == "true"
+        self.guards = {}
+        self._initialize_guards()
+    
+    def _initialize_guards(self):
+        """Initialize different types of guards for various use cases"""
+        try:
+            if not self.enabled:
+                return
+            
+            # Input validation guard
+            self.guards["input_safety"] = self._create_input_safety_guard()
+            
+            # Output validation guard
+            self.guards["output_quality"] = self._create_output_quality_guard()
+            
+            # Content moderation guard
+            self.guards["content_moderation"] = self._create_content_moderation_guard()
+            
+            # Structured output guard
+            self.guards["structured_output"] = self._create_structured_output_guard()
+            
+        except Exception as e:
+            # Fail silently - guardrails should not break the app
+            if os.getenv("STREAMLIT_ENV") != "production":
+                st.warning(f"⚠️ Guardrails initialization failed: {e}")
+            self.enabled = False
+    
+    def _create_input_safety_guard(self) -> Guard:
+        """Create guard for input safety validation"""
+        try:
+            return Guard().use(
+                ToxicLanguage(threshold=0.8, validation_method="sentence"),
+                ProfanityFree(),
+                ValidLength(min=1, max=2000)
+            )
+        except Exception:
+            return None
+    
+    def _create_output_quality_guard(self) -> Guard:
+        """Create guard for output quality validation"""
+        try:
+            return Guard().use(
+                ValidLength(min=10, max=5000),
+                ReadingTime(reading_time_range=(1, 300))  # 1-300 seconds reading time
+            )
+        except Exception:
+            return None
+    
+    def _create_content_moderation_guard(self) -> Guard:
+        """Create guard for content moderation"""
+        try:
+            sensitive_topics = [
+                "violence", "hate_speech", "harassment", 
+                "illegal_activities", "self_harm"
+            ]
+            return Guard().use(
+                SensitiveTopics(sensitive_topics=sensitive_topics, threshold=0.8),
+                ToxicLanguage(threshold=0.7, validation_method="full")
+            )
+        except Exception:
+            return None
+    
+    def _create_structured_output_guard(self) -> Guard:
+        """Create guard for structured output validation"""
+        try:
+            class ChatResponse(BaseModel):
+                content: str = Field(description="The main response content")
+                confidence: float = Field(ge=0.0, le=1.0, description="Confidence score")
+                safe: bool = Field(description="Whether the response is safe")
+            
+            return Guard.from_pydantic(ChatResponse)
+        except Exception:
+            return None
+    
+    def get_guard(self, guard_type: str) -> Optional[Guard]:
+        """Get a specific guard by type"""
+        if not self.enabled:
+            return None
+        return self.guards.get(guard_type)
+    
+    def is_enabled(self) -> bool:
+        """Check if guardrails are enabled"""
+        return self.enabled and len(self.guards) > 0
+
+
+# Global instance
+guardrails_config = GuardrailsConfig()

src/langgraphagenticai/guardrails/llm_wrapper.py

@@ -0,0 +1,160 @@
+"""
+Guardrails LLM Wrapper
+Wraps LLM calls with input/output validation
+"""
+from typing import Any, List, Optional, Dict
+from langchain_core.language_models.base import BaseLanguageModel
+from langchain_core.messages import BaseMessage, AIMessage, HumanMessage
+from langchain_core.callbacks import CallbackManagerForLLMRun
+from .validation_service import validation_service
+import streamlit as st
+
+
+class GuardrailsLLMWrapper(BaseLanguageModel):
+    """
+    Wrapper that adds Guardrails validation to any LangChain LLM
+    """
+    
+    def __init__(self, llm: BaseLanguageModel, usecase: str = "general"):
+        self.llm = llm
+        self.usecase = usecase
+        self.validation_service = validation_service
+    
+    def _generate(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> Any:
+        """Generate response with input/output validation"""
+        try:
+            # Extract user input for validation
+            user_input = ""
+            if messages:
+                last_message = messages[-1]
+                if isinstance(last_message, HumanMessage):
+                    user_input = last_message.content
+            
+            # Validate input
+            if user_input:
+                is_valid, processed_input, error_msg = self.validation_service.validate_user_input(user_input)
+                
+                if not is_valid:
+                    # Show warning to user
+                    if error_msg:
+                        st.warning(f"🛡️ Input Safety: {error_msg}")
+                    
+                    # Return safe response
+                    safe_response = "I cannot process this request due to safety guidelines. Please rephrase your question."
+                    return self.llm._generate([HumanMessage(content=safe_response)], stop, run_manager, **kwargs)
+                
+                # Update message with processed input if it was modified
+                if processed_input != user_input:
+                    messages[-1] = HumanMessage(content=processed_input)
+            
+            # Call original LLM
+            result = self.llm._generate(messages, stop, run_manager, **kwargs)
+            
+            # Validate output
+            if result and hasattr(result, 'generations') and result.generations:
+                for generation in result.generations:
+                    if hasattr(generation, 'message') and hasattr(generation.message, 'content'):
+                        output_content = generation.message.content
+                        
+                        is_valid, processed_output, error_msg = self.validation_service.validate_llm_output(
+                            output_content, self.usecase
+                        )
+                        
+                        if not is_valid:
+                            # Show warning to user
+                            if error_msg:
+                                st.warning(f"🛡️ Output Safety: Response was filtered for safety")
+                            
+                            # Replace with processed (safe) output
+                            generation.message.content = processed_output
+            
+            return result
+            
+        except Exception as e:
+            # If validation fails, fall back to original LLM
+            return self.llm._generate(messages, stop, run_manager, **kwargs)
+    
+    def invoke(self, input_data, config=None, **kwargs):
+        """Invoke with validation"""
+        try:
+            # Handle different input types
+            if isinstance(input_data, str):
+                # Validate string input
+                is_valid, processed_input, error_msg = self.validation_service.validate_user_input(input_data)
+                
+                if not is_valid:
+                    if error_msg:
+                        st.warning(f"🛡️ Input Safety: {error_msg}")
+                    return AIMessage(content="I cannot process this request due to safety guidelines. Please rephrase your question.")
+                
+                input_data = processed_input
+            
+            elif isinstance(input_data, list):
+                # Validate list of messages
+                for i, message in enumerate(input_data):
+                    if isinstance(message, HumanMessage):
+                        is_valid, processed_input, error_msg = self.validation_service.validate_user_input(message.content)
+                        
+                        if not is_valid:
+                            if error_msg:
+                                st.warning(f"🛡️ Input Safety: {error_msg}")
+                            return AIMessage(content="I cannot process this request due to safety guidelines. Please rephrase your question.")
+                        
+                        if processed_input != message.content:
+                            input_data[i] = HumanMessage(content=processed_input)
+            
+            # Call original LLM
+            result = self.llm.invoke(input_data, config, **kwargs)
+            
+            # Validate output
+            if isinstance(result, AIMessage) and result.content:
+                is_valid, processed_output, error_msg = self.validation_service.validate_llm_output(
+                    result.content, self.usecase
+                )
+                
+                if not is_valid:
+                    if error_msg:
+                        st.warning(f"🛡️ Output Safety: Response was filtered for safety")
+                    result.content = processed_output
+            
+            return result
+            
+        except Exception as e:
+            # Fall back to original LLM
+            return self.llm.invoke(input_data, config, **kwargs)
+    
+    def bind_tools(self, tools, **kwargs):
+        """Bind tools and return wrapped LLM"""
+        bound_llm = self.llm.bind_tools(tools, **kwargs)
+        return GuardrailsLLMWrapper(bound_llm, self.usecase)
+    
+    def __getattr__(self, name):
+        """Delegate other attributes to the wrapped LLM"""
+        return getattr(self.llm, name)
+
+
+def create_guardrails_llm(llm: BaseLanguageModel, usecase: str = "general") -> BaseLanguageModel:
+    """
+    Create a Guardrails-wrapped LLM
+    
+    Args:
+        llm: The original LLM to wrap
+        usecase: The use case for appropriate validation rules
+    
+    Returns:
+        Wrapped LLM with Guardrails validation
+    """
+    try:
+        if validation_service.config.is_enabled():
+            return GuardrailsLLMWrapper(llm, usecase)
+        else:
+            return llm
+    except Exception:
+        # If wrapping fails, return original LLM
+        return llm

src/langgraphagenticai/guardrails/validation_service.py

@@ -0,0 +1,140 @@
+"""
+Guardrails Validation Service
+Provides validation methods for inputs and outputs
+"""
+import streamlit as st
+from typing import Dict, Any, Optional, Tuple
+from guardrails import ValidationOutcome
+from .guardrails_config import guardrails_config
+
+
+class ValidationService:
+    """Service for validating inputs and outputs using Guardrails"""
+    
+    def __init__(self):
+        self.config = guardrails_config
+    
+    def validate_user_input(self, user_input: str) -> Tuple[bool, str, Optional[str]]:
+        """
+        Validate user input for safety and appropriateness
+        
+        Returns:
+            Tuple[bool, str, Optional[str]]: (is_valid, processed_input, error_message)
+        """
+        try:
+            if not self.config.is_enabled():
+                return True, user_input, None
+            
+            # Get input safety guard
+            guard = self.config.get_guard("input_safety")
+            if not guard:
+                return True, user_input, None
+            
+            # Validate input
+            result = guard.validate(user_input)
+            
+            if result.validation_passed:
+                return True, result.validated_output, None
+            else:
+                # Extract error messages
+                errors = []
+                for failure in result.validation_failures:
+                    errors.append(failure.error_message)
+                
+                error_msg = "Input validation failed: " + "; ".join(errors)
+                return False, user_input, error_msg
+                
+        except Exception as e:
+            # Fail silently - validation should not break the app
+            return True, user_input, None
+    
+    def validate_llm_output(self, llm_output: str, usecase: str = "general") -> Tuple[bool, str, Optional[str]]:
+        """
+        Validate LLM output for quality and safety
+        
+        Returns:
+            Tuple[bool, str, Optional[str]]: (is_valid, processed_output, error_message)
+        """
+        try:
+            if not self.config.is_enabled():
+                return True, llm_output, None
+            
+            # Get appropriate guard based on use case
+            if usecase in ["MCP Chatbot", "Chatbot with Tool"]:
+                guard = self.config.get_guard("content_moderation")
+            else:
+                guard = self.config.get_guard("output_quality")
+            
+            if not guard:
+                return True, llm_output, None
+            
+            # Validate output
+            result = guard.validate(llm_output)
+            
+            if result.validation_passed:
+                return True, result.validated_output, None
+            else:
+                # Extract error messages
+                errors = []
+                for failure in result.validation_failures:
+                    errors.append(failure.error_message)
+                
+                error_msg = "Output validation failed: " + "; ".join(errors)
+                
+                # Return a safe fallback message
+                safe_output = "I apologize, but I cannot provide a response that meets safety guidelines. Please try rephrasing your question."
+                return False, safe_output, error_msg
+                
+        except Exception as e:
+            # Fail silently - validation should not break the app
+            return True, llm_output, None
+    
+    def moderate_content(self, content: str) -> Tuple[bool, Optional[str]]:
+        """
+        Moderate content for sensitive topics and harmful content
+        
+        Returns:
+            Tuple[bool, Optional[str]]: (is_safe, warning_message)
+        """
+        try:
+            if not self.config.is_enabled():
+                return True, None
+            
+            guard = self.config.get_guard("content_moderation")
+            if not guard:
+                return True, None
+            
+            result = guard.validate(content)
+            
+            if result.validation_passed:
+                return True, None
+            else:
+                # Extract warning messages
+                warnings = []
+                for failure in result.validation_failures:
+                    warnings.append(failure.error_message)
+                
+                warning_msg = "Content moderation warning: " + "; ".join(warnings)
+                return False, warning_msg
+                
+        except Exception as e:
+            # Fail silently
+            return True, None
+    
+    def get_validation_stats(self) -> Dict[str, Any]:
+        """Get validation statistics"""
+        try:
+            if not self.config.is_enabled():
+                return {"enabled": False}
+            
+            return {
+                "enabled": True,
+                "guards_available": list(self.config.guards.keys()),
+                "total_guards": len(self.config.guards)
+            }
+        except Exception:
+            return {"enabled": False}
+
+
+# Global instance
+validation_service = ValidationService()

src/langgraphagenticai/llms/groqllm.py

@@ -2,13 +2,14 @@ import os
 import streamlit as st
 from langchain_groq import ChatGroq
 from src.langgraphagenticai.monitoring.langfuse_integration import create_monitored_llm, get_langfuse_callbacks
+from src.langgraphagenticai.guardrails.llm_wrapper import create_guardrails_llm
 
 
 class GroqLLM:
     def __init__(self, user_controls_input):
         self.user_controls_input = user_controls_input
 
-    def get_llm_model(self):
+    def get_llm_model(self, usecase: str = "general"):
         try:
             groq_api_key = self.user_controls_input.get("GROQ_API_KEY")
             selected_groq_model = self.user_controls_input.get("selected_groq_model")
@@ -17,12 +18,19 @@ class GroqLLM:
                 st.error("Please enter the GROQ API key and select a model")
                 return None
 
-            # Create base LLM first (without monitoring)
+            # Create base LLM first
             llm = ChatGroq(
                 api_key=groq_api_key, 
                 model=selected_groq_model
             )
             
+            # Add Guardrails protection
+            try:
+                llm = create_guardrails_llm(llm, usecase)
+            except Exception:
+                # If Guardrails fails, continue without it
+                pass
+            
             # Try to add monitoring, but don't fail if it doesn't work
             try:
                 callbacks = get_langfuse_callbacks()
@@ -33,7 +41,7 @@ class GroqLLM:
                 monitored_llm = create_monitored_llm(llm)
                 return monitored_llm
             except Exception:
-                # If monitoring fails, return the base LLM
+                # If monitoring fails, return the LLM (possibly with Guardrails)
                 return llm
         except Exception as e:
             st.error(f"Error initializing ChatGroq: {str(e)}")

src/langgraphagenticai/main.py

@@ -31,16 +31,18 @@ def load_langgraph_agenticai_app():
 
     if user_message:
         try:
-            # Configure LLM
+            # Get usecase first
+            usecase = user_input.get("selected_usecase", "general")
+            
+            # Configure LLM with usecase for appropriate guardrails
             obj_llm_config = GroqLLM(user_controls_input=user_input)
-            model = obj_llm_config.get_llm_model()
+            model = obj_llm_config.get_llm_model(usecase=usecase)
 
             if not model:
                 st.error("Error: LLM model could not be initialized")
                 return
 
-            # initialize and setup graph based on usecase
-            usecase = user_input.get("selected_usecase")
+            # Validate usecase
             if not usecase:
                 st.error("Error: no usecase selected")
                 return

src/langgraphagenticai/ui/streamlitui/display_result.py

@@ -81,9 +81,19 @@ class DisplayResultStremlit:
                                         except Exception:
                                             pass
             
-            # Show cost tracking info - fail silently if monitoring unavailable
+            # Show safety and monitoring info
             try:
                 show_cost_tracking()
+                self._show_safety_info()
             except Exception:
                 pass
+    
+    def _show_safety_info(self):
+        """Show safety information"""
+        try:
+            from src.langgraphagenticai.guardrails.validation_service import validation_service
+            if validation_service.config.is_enabled():
+                st.info("🛡️ This conversation is protected by Guardrails AI for safety and quality.")
+        except Exception:
+            pass
                 

src/langgraphagenticai/ui/streamlitui/loadui.py

@@ -42,15 +42,31 @@ class LoadStreamlitUI:
         
 
         with st.sidebar:
+            # Safety and Monitoring Status
+            st.subheader("🛡️ Safety & Monitoring")
+            
+            # Guardrails status
+            try:
+                from src.langgraphagenticai.guardrails.validation_service import validation_service
+                if validation_service.config.is_enabled():
+                    st.success("🛡️ Guardrails: ON")
+                    stats = validation_service.get_validation_stats()
+                    if stats.get("total_guards", 0) > 0:
+                        st.caption(f"Active guards: {stats['total_guards']}")
+                else:
+                    st.info("🛡️ Guardrails: OFF")
+            except Exception:
+                pass
+            
             # 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")
+                    st.success("📊 Monitoring: ON")
                     dashboard_url = langfuse_manager.get_dashboard_url()
                     st.markdown(f"[📈 View Dashboard]({dashboard_url})")
                 else:
-                    st.info("📊 Langfuse Monitoring: OFF")
+                    st.info("📊 Monitoring: OFF")
             except Exception:
                 # If monitoring status can't be determined, don't show anything
                 pass