feat: update .gitignore and remove outdated design, requirements, and tasks documents for enhanced guardrails system

.gitignore

@@ -1,2 +1,162 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
 .env
-venv
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

.kiro/specs/enhanced-guardrails-system/design.md

@@ -1,330 +0,0 @@
-# Design Document
-
-## Overview
-
-The Enhanced Guardrails System extends the existing guardrails functionality by integrating Guardrails Hub validators, implementing comprehensive input/output guards, and adding support for structured data generation. The design maintains backward compatibility while adding robust validation capabilities that can operate both embedded and as a standalone service.
-
-## Architecture
-
-### High-Level Architecture
-
-```mermaid
-graph TB
-    subgraph "Client Layer"
-        UI[Streamlit UI]
-        API[REST API]
-    end
-    
-    subgraph "Guardrails Layer"
-        GS[Guardrails Service]
-        GC[Guard Coordinator]
-        HI[Hub Integration]
-    end
-    
-    subgraph "Validation Guards"
-        IG[Input Guards]
-        OG[Output Guards]
-        SG[Structured Guards]
-        CG[Content Guards]
-    end
-    
-    subgraph "LLM Layer"
-        LW[LLM Wrapper]
-        LLM[Language Models]
-    end
-    
-    subgraph "External Services"
-        GH[Guardrails Hub]
-        FS[Flask Server]
-    end
-    
-    UI --> GS
-    API --> GS
-    GS --> GC
-    GC --> IG
-    GC --> OG
-    GC --> SG
-    GC --> CG
-    GC --> LW
-    LW --> LLM
-    HI --> GH
-    GS --> FS
-```
-
-### Component Interaction Flow
-
-```mermaid
-sequenceDiagram
-    participant User
-    participant UI
-    participant GuardService
-    participant InputGuards
-    participant LLMWrapper
-    participant OutputGuards
-    participant LLM
-    
-    User->>UI: Submit Input
-    UI->>GuardService: Validate Request
-    GuardService->>InputGuards: Apply Input Validation
-    InputGuards-->>GuardService: Validation Result
-    
-    alt Input Valid
-        GuardService->>LLMWrapper: Process Request
-        LLMWrapper->>LLM: Generate Response
-        LLM-->>LLMWrapper: Raw Response
-        LLMWrapper->>OutputGuards: Validate Output
-        OutputGuards-->>LLMWrapper: Validated Output
-        LLMWrapper-->>GuardService: Final Response
-        GuardService-->>UI: Safe Response
-        UI-->>User: Display Result
-    else Input Invalid
-        GuardService-->>UI: Validation Error
-        UI-->>User: Error Message
-    end
-```
-
-## Components and Interfaces
-
-### 1. Enhanced Guardrails Configuration
-
-**Purpose:** Manages Guardrails Hub integration and guard configurations
-
-**Key Interfaces:**
-```python
-class EnhancedGuardrailsConfig:
-    def install_hub_validator(self, validator_name: str) -> bool
-    def create_guard_from_hub(self, validators: List[str], config: Dict) -> Guard
-    def get_structured_guard(self, model_class: BaseModel) -> Guard
-    def configure_server_mode(self, host: str, port: int) -> bool
-```
-
-**Responsibilities:**
-- Manage Guardrails Hub CLI integration
-- Cache installed validators
-- Configure guard combinations
-- Handle server mode setup
-
-### 2. Guard Factory
-
-**Purpose:** Creates and manages different types of guards based on use cases
-
-**Key Interfaces:**
-```python
-class GuardFactory:
-    def create_input_guard(self, validators: List[str]) -> Guard
-    def create_output_guard(self, quality_rules: Dict) -> Guard
-    def create_structured_guard(self, schema: BaseModel) -> Guard
-    def create_composite_guard(self, guard_configs: List[Dict]) -> Guard
-```
-
-**Responsibilities:**
-- Instantiate guards with proper configurations
-- Manage guard lifecycle
-- Handle guard composition and chaining
-
-### 3. Validation Orchestrator
-
-**Purpose:** Coordinates validation across multiple guards and handles failures
-
-**Key Interfaces:**
-```python
-class ValidationOrchestrator:
-    def validate_input(self, content: str, context: Dict) -> ValidationResult
-    def validate_output(self, content: str, schema: Optional[BaseModel]) -> ValidationResult
-    def apply_corrections(self, content: str, failures: List[ValidationFailure]) -> str
-    def get_validation_metrics(self) -> Dict[str, Any]
-```
-
-**Responsibilities:**
-- Execute validation pipelines
-- Handle validation failures and retries
-- Apply automatic corrections
-- Collect validation metrics
-
-### 4. Hub Integration Manager
-
-**Purpose:** Manages integration with Guardrails Hub for validator installation and updates
-
-**Key Interfaces:**
-```python
-class HubIntegrationManager:
-    def configure_hub_cli(self) -> bool
-    def install_validator(self, hub_path: str) -> bool
-    def list_available_validators(self) -> List[str]
-    def update_validators(self) -> Dict[str, bool]
-```
-
-**Responsibilities:**
-- Configure Guardrails Hub CLI
-- Install and update validators
-- Manage validator dependencies
-- Handle offline fallbacks
-
-### 5. Structured Data Generator
-
-**Purpose:** Generates structured data from LLMs using Pydantic models and Guardrails
-
-**Key Interfaces:**
-```python
-class StructuredDataGenerator:
-    def generate_with_schema(self, prompt: str, schema: BaseModel, llm: BaseLanguageModel) -> Any
-    def validate_structured_output(self, data: Any, schema: BaseModel) -> ValidationResult
-    def handle_function_calling(self, llm: BaseLanguageModel, schema: BaseModel) -> bool
-    def optimize_prompt_for_schema(self, prompt: str, schema: BaseModel) -> str
-```
-
-**Responsibilities:**
-- Generate structured data using function calling or prompt optimization
-- Validate structured outputs against Pydantic schemas
-- Handle LLM compatibility differences
-- Retry failed structured generation
-
-### 6. Guardrails Server Interface
-
-**Purpose:** Provides REST API interface for standalone Guardrails service
-
-**Key Interfaces:**
-```python
-class GuardrailsServerInterface:
-    def start_server(self, config_path: str, host: str, port: int) -> bool
-    def validate_via_api(self, content: str, guard_name: str) -> ValidationResult
-    def proxy_openai_request(self, request: Dict) -> Dict
-    def health_check(self) -> bool
-```
-
-**Responsibilities:**
-- Start and manage Flask server
-- Provide REST API endpoints
-- Handle OpenAI SDK proxy functionality
-- Monitor server health
-
-## Data Models
-
-### Validation Result Model
-```python
-class ValidationResult(BaseModel):
-    is_valid: bool
-    processed_content: str
-    original_content: str
-    failures: List[ValidationFailure]
-    corrections_applied: List[str]
-    validation_time: float
-    guard_name: str
-```
-
-### Guard Configuration Model
-```python
-class GuardConfig(BaseModel):
-    name: str
-    validators: List[ValidatorConfig]
-    failure_action: OnFailAction
-    retry_count: int = 3
-    timeout: float = 30.0
-    enabled: bool = True
-```
-
-### Validator Configuration Model
-```python
-class ValidatorConfig(BaseModel):
-    type: str  # "hub", "builtin", "custom"
-    name: str
-    parameters: Dict[str, Any]
-    on_fail: OnFailAction
-    priority: int = 0
-```
-
-### Structured Schema Registry
-```python
-class SchemaRegistry:
-    def register_schema(self, name: str, schema: BaseModel) -> None
-    def get_schema(self, name: str) -> Optional[BaseModel]
-    def list_schemas(self) -> List[str]
-```
-
-## Error Handling
-
-### Validation Failure Handling
-1. **Input Validation Failures:**
-   - Log failure details with context
-   - Provide user-friendly error messages
-   - Offer suggestions for correction
-   - Block processing until valid input
-
-2. **Output Validation Failures:**
-   - Apply automatic corrections when possible
-   - Regenerate response with modified prompts
-   - Fallback to safe default responses
-   - Log incidents for analysis
-
-3. **Hub Integration Failures:**
-   - Cache validators locally for offline use
-   - Fallback to built-in validators
-   - Retry with exponential backoff
-   - Graceful degradation of functionality
-
-4. **Server Mode Failures:**
-   - Automatic fallback to embedded mode
-   - Health check monitoring
-   - Circuit breaker pattern for resilience
-   - Connection pooling and retry logic
-
-### Error Recovery Strategies
-```python
-class ErrorRecoveryStrategy:
-    def handle_validation_timeout(self, context: Dict) -> ValidationResult
-    def handle_hub_unavailable(self, validator_name: str) -> Guard
-    def handle_server_unreachable(self) -> None
-    def handle_schema_validation_error(self, data: Any, schema: BaseModel) -> Any
-```
-
-## Testing Strategy
-
-### Unit Testing
-- **Guard Factory Tests:** Verify correct guard instantiation and configuration
-- **Validation Logic Tests:** Test individual validator behavior and edge cases
-- **Hub Integration Tests:** Mock Hub API responses and test error handling
-- **Structured Generation Tests:** Validate schema compliance and data integrity
-
-### Integration Testing
-- **End-to-End Validation Flow:** Test complete input → processing → output pipeline
-- **Server Mode Integration:** Test REST API functionality and OpenAI proxy
-- **LLM Wrapper Integration:** Verify seamless integration with existing LLM calls
-- **Fallback Mechanism Tests:** Test graceful degradation scenarios
-
-### Performance Testing
-- **Validation Latency:** Measure impact on response times
-- **Concurrent Validation:** Test multiple simultaneous validation requests
-- **Memory Usage:** Monitor memory consumption with large guard configurations
-- **Server Scalability:** Test Guardrails server under load
-
-### Security Testing
-- **Input Sanitization:** Test malicious input handling
-- **Output Filtering:** Verify sensitive content detection and removal
-- **Configuration Security:** Test secure storage of guard configurations
-- **API Security:** Validate REST API authentication and authorization
-
-## Implementation Phases
-
-### Phase 1: Hub Integration Foundation
-- Configure Guardrails Hub CLI integration
-- Implement validator installation and caching
-- Create basic guard factory with hub validators
-- Add configuration management for hub validators
-
-### Phase 2: Enhanced Input/Output Guards
-- Extend existing input validation with hub validators
-- Implement comprehensive output quality guards
-- Add structured data generation capabilities
-- Integrate with existing LLM wrapper
-
-### Phase 3: Server Mode Implementation
-- Implement Guardrails Flask server
-- Add REST API endpoints for validation
-- Create OpenAI SDK proxy functionality
-- Implement health monitoring and fallback
-
-### Phase 4: Advanced Features and Optimization
-- Add validation metrics and monitoring
-- Implement advanced error recovery
-- Optimize performance for production use
-- Add comprehensive logging and debugging

.kiro/specs/enhanced-guardrails-system/requirements.md

@@ -1,84 +0,0 @@
-# Requirements Document
-
-## Introduction
-
-This feature enhances the existing guardrails system in the LangGraph Agentic AI application by integrating comprehensive input and output guards using the Guardrails Hub. The enhancement will provide robust validation, safety measures, and structured data generation capabilities for LLM interactions, ensuring reliable and safe AI responses while maintaining the existing application architecture.
-
-## Requirements
-
-### Requirement 1
-
-**User Story:** As a developer, I want to configure and use Guardrails Hub validators so that I can leverage pre-built validation rules for common use cases.
-
-#### Acceptance Criteria
-
-1. WHEN the application starts THEN the system SHALL automatically configure Guardrails Hub CLI integration
-2. WHEN installing guardrails from the hub THEN the system SHALL support regex matching, competitor checking, and toxic language detection
-3. WHEN a guardrail is installed THEN the system SHALL cache the configuration for reuse across sessions
-4. IF Guardrails Hub is unavailable THEN the system SHALL gracefully fallback to basic validation without breaking functionality
-
-### Requirement 2
-
-**User Story:** As a system administrator, I want comprehensive input validation guards so that malicious or inappropriate content is filtered before reaching the LLM.
-
-#### Acceptance Criteria
-
-1. WHEN user input is received THEN the system SHALL validate against regex patterns, toxic language, and profanity
-2. WHEN input validation fails THEN the system SHALL provide clear error messages and prevent LLM processing
-3. WHEN competitor names are detected THEN the system SHALL either block or sanitize the content based on configuration
-4. IF input exceeds length limits THEN the system SHALL reject the input with appropriate feedback
-
-### Requirement 3
-
-**User Story:** As a developer, I want output validation guards so that LLM responses meet quality and safety standards before being returned to users.
-
-#### Acceptance Criteria
-
-1. WHEN LLM generates a response THEN the system SHALL validate output for toxic content, length, and readability
-2. WHEN output validation fails THEN the system SHALL either regenerate the response or apply corrective measures
-3. WHEN structured data is requested THEN the system SHALL enforce Pydantic model validation
-4. IF output contains sensitive information THEN the system SHALL sanitize or block the response
-
-### Requirement 4
-
-**User Story:** As a developer, I want to generate structured data from LLMs using Guardrails so that I can ensure consistent output formats for downstream processing.
-
-#### Acceptance Criteria
-
-1. WHEN requesting structured output THEN the system SHALL use Pydantic models to define expected schemas
-2. WHEN LLM supports function calling THEN the system SHALL use function call syntax for structured generation
-3. WHEN LLM doesn't support function calling THEN the system SHALL use prompt optimization with schema injection
-4. IF structured validation fails THEN the system SHALL retry with corrected prompts up to a configurable limit
-
-### Requirement 5
-
-**User Story:** As a system operator, I want Guardrails to run as a standalone service so that I can scale validation independently and integrate with multiple applications.
-
-#### Acceptance Criteria
-
-1. WHEN deploying the application THEN the system SHALL support running Guardrails as a Flask service
-2. WHEN using Guardrails server THEN the system SHALL provide REST API endpoints for validation
-3. WHEN integrating with OpenAI SDK THEN the system SHALL support transparent proxy functionality
-4. IF the Guardrails server is unavailable THEN the system SHALL fallback to embedded validation
-
-### Requirement 6
-
-**User Story:** As a developer, I want configurable guard combinations so that I can apply multiple validation rules simultaneously based on use case requirements.
-
-#### Acceptance Criteria
-
-1. WHEN configuring guards THEN the system SHALL support chaining multiple validators with different failure actions
-2. WHEN validation fails THEN the system SHALL provide detailed feedback about which specific guards failed
-3. WHEN guards conflict THEN the system SHALL apply a configurable precedence order
-4. IF performance is impacted THEN the system SHALL support async validation for non-blocking operations
-
-### Requirement 7
-
-**User Story:** As a system administrator, I want comprehensive monitoring and logging of guard activities so that I can track validation effectiveness and troubleshoot issues.
-
-#### Acceptance Criteria
-
-1. WHEN guards are executed THEN the system SHALL log validation attempts, results, and performance metrics
-2. WHEN validation fails THEN the system SHALL capture detailed error information for analysis
-3. WHEN guards are bypassed THEN the system SHALL log the bypass reason and context
-4. IF monitoring data exceeds storage limits THEN the system SHALL implement configurable retention policies

.kiro/specs/enhanced-guardrails-system/tasks.md

@@ -1,95 +0,0 @@
-# Implementation Plan
-
-- [ ] 1. Set up Guardrails Hub integration foundation
-  - Update requirements.txt with additional Guardrails Hub dependencies
-  - Create hub integration manager class with CLI configuration methods
-  - Implement validator installation and caching functionality
-  - Add error handling for hub connectivity issues
-  - _Requirements: 1.1, 1.2, 1.3, 1.4_
-
-- [ ] 2. Create enhanced guard factory and configuration system
-  - Extend GuardrailsConfig class to support hub validators
-  - Implement GuardFactory class for creating different guard types
-  - Add methods for installing regex_match, competitor_check, and toxic_language validators
-  - Create configuration caching system for installed validators
-  - _Requirements: 1.1, 1.2, 6.1, 6.2_
-
-- [ ] 3. Implement comprehensive input validation guards
-  - Create enhanced input validation methods using hub validators
-  - Add regex pattern validation for phone numbers and other formats
-  - Implement competitor name detection and filtering
-  - Add configurable input length and content validation
-  - Write unit tests for input validation scenarios
-  - _Requirements: 2.1, 2.2, 2.3, 2.4_
-
-- [ ] 4. Develop advanced output validation and quality guards
-  - Implement output quality validation using hub validators
-  - Add toxic language detection for LLM responses
-  - Create output length and readability validation
-  - Implement sensitive information detection and sanitization
-  - Write unit tests for output validation scenarios
-  - _Requirements: 3.1, 3.2, 3.4_
-
-- [ ] 5. Create structured data generation system
-  - Implement StructuredDataGenerator class with Pydantic model support
-  - Add function calling detection and implementation for compatible LLMs
-  - Create prompt optimization for non-function-calling LLMs
-  - Implement schema validation and retry logic for failed generations
-  - Write unit tests for structured data generation
-  - _Requirements: 4.1, 4.2, 4.3, 4.4_
-
-- [ ] 6. Implement validation orchestrator and error handling
-  - Create ValidationOrchestrator class to coordinate multiple guards
-  - Implement guard chaining and precedence handling
-  - Add automatic correction and retry mechanisms
-  - Create comprehensive error recovery strategies
-  - Write unit tests for orchestration scenarios
-  - _Requirements: 6.1, 6.2, 6.3_
-
-- [ ] 7. Build Guardrails server interface and REST API
-  - Create GuardrailsServerInterface class for Flask server management
-  - Implement REST API endpoints for validation services
-  - Add OpenAI SDK proxy functionality for transparent integration
-  - Implement health check and monitoring endpoints
-  - Write integration tests for server functionality
-  - _Requirements: 5.1, 5.2, 5.3, 5.4_
-
-- [ ] 8. Enhance existing LLM wrapper with new capabilities
-  - Update GuardrailsLLMWrapper to use new validation orchestrator
-  - Add support for structured data generation in LLM calls
-  - Implement fallback mechanisms for validation failures
-  - Add async validation support for improved performance
-  - Write integration tests for enhanced LLM wrapper
-  - _Requirements: 3.1, 3.2, 4.1, 6.4_
-
-- [ ] 9. Add comprehensive monitoring and logging system
-  - Implement validation metrics collection and reporting
-  - Add detailed logging for guard execution and failures
-  - Create performance monitoring for validation latency
-  - Implement configurable retention policies for monitoring data
-  - Write unit tests for monitoring functionality
-  - _Requirements: 7.1, 7.2, 7.3, 7.4_
-
-- [ ] 10. Create configuration management and deployment setup
-  - Add Docker configuration for Guardrails server deployment
-  - Create environment-based configuration management
-  - Implement graceful fallback when Guardrails server is unavailable
-  - Add production deployment scripts and documentation
-  - Write end-to-end integration tests for complete system
-  - _Requirements: 5.1, 5.4, 1.4_
-
-- [ ] 11. Update existing application integration points
-  - Modify existing node classes to use enhanced guardrails
-  - Update Streamlit UI to display new validation feedback
-  - Integrate structured data generation with existing workflows
-  - Add configuration options in UI for guard selection
-  - Write integration tests for updated application components
-  - _Requirements: 2.2, 3.2, 4.1, 6.2_
-
-- [ ] 12. Implement comprehensive testing and validation
-  - Create performance benchmarks for validation latency
-  - Add security tests for malicious input handling
-  - Implement load testing for Guardrails server
-  - Create end-to-end tests for all validation scenarios
-  - Add documentation and examples for new features
-  - _Requirements: 2.1, 3.1, 5.2, 7.1_