docs: expand documentation with new sections and deployment guides

- Add Examples section to MkDocs navigation
- Create initial Examples overview page with placeholder content
- Add Docker deployment guide to Getting Started section
- Update installation documentation with Smithery configuration details

README.md

@@ -58,17 +58,17 @@ Our architecture is engineered for performance, scalability, and security. The f
 ```mermaid
 graph TD
     subgraph Client
-       A[Client Application\n(Web / Mobile / Voice)]
+       A[Client Application<br>(Web / Mobile / Voice)]
     end
     subgraph CDN
        B[CDN / Cache]
     end
     subgraph Server
        C[Bun Native Server]
-       E[NLP Engine &\nLanguage Processing Module]
+       E[NLP Engine &<br>Language Processing Module]
     end
     subgraph Integration
-       D[Home Assistant\n(Devices, Lights, Thermostats)]
+       D[Home Assistant<br>(Devices, Lights, Thermostats)]
     end
 
     A -->|HTTP Request| B

docs/api/core.md

@@ -0,0 +1,326 @@
+---
+layout: default
+title: Core Functions
+parent: API Reference
+nav_order: 3
+---
+
+# Core Functions API 🔧
+
+The Core Functions API provides the fundamental operations for interacting with Home Assistant devices and services through MCP Server.
+
+## Device Control
+
+### Get Device State
+
+Retrieve the current state of devices.
+
+```http
+GET /api/state
+GET /api/state/{entity_id}
+```
+
+Parameters:
+- `entity_id` (optional): Specific device ID to query
+
+```bash
+# Get all states
+curl http://localhost:3000/api/state
+
+# Get specific device state
+curl http://localhost:3000/api/state/light.living_room
+```
+
+Response:
+```json
+{
+  "entity_id": "light.living_room",
+  "state": "on",
+  "attributes": {
+    "brightness": 255,
+    "color_temp": 370,
+    "friendly_name": "Living Room Light"
+  },
+  "last_changed": "2024-01-20T15:30:00Z"
+}
+```
+
+### Control Device
+
+Execute device commands.
+
+```http
+POST /api/device/control
+```
+
+Request body:
+```json
+{
+  "entity_id": "light.living_room",
+  "action": "turn_on",
+  "parameters": {
+    "brightness": 200,
+    "color_temp": 400
+  }
+}
+```
+
+Available actions:
+- `turn_on`
+- `turn_off`
+- `toggle`
+- `set_value`
+
+Example with curl:
+```bash
+curl -X POST http://localhost:3000/api/device/control \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
+  -d '{
+    "entity_id": "light.living_room",
+    "action": "turn_on",
+    "parameters": {
+      "brightness": 200
+    }
+  }'
+```
+
+## Natural Language Commands
+
+### Execute Command
+
+Process natural language commands.
+
+```http
+POST /api/command
+```
+
+Request body:
+```json
+{
+  "command": "Turn on the living room lights and set them to 50% brightness"
+}
+```
+
+Example usage:
+```bash
+curl -X POST http://localhost:3000/api/command \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
+  -d '{
+    "command": "Turn on the living room lights and set them to 50% brightness"
+  }'
+```
+
+Response:
+```json
+{
+  "success": true,
+  "actions": [
+    {
+      "entity_id": "light.living_room",
+      "action": "turn_on",
+      "parameters": {
+        "brightness": 127
+      },
+      "status": "completed"
+    }
+  ],
+  "message": "Command executed successfully"
+}
+```
+
+## Scene Management
+
+### Create Scene
+
+Define a new scene with multiple actions.
+
+```http
+POST /api/scene
+```
+
+Request body:
+```json
+{
+  "name": "Movie Night",
+  "description": "Perfect lighting for movie watching",
+  "actions": [
+    {
+      "entity_id": "light.living_room",
+      "action": "turn_on",
+      "parameters": {
+        "brightness": 50,
+        "color_temp": 500
+      }
+    },
+    {
+      "entity_id": "cover.living_room",
+      "action": "close"
+    }
+  ]
+}
+```
+
+### Activate Scene
+
+Trigger a predefined scene.
+
+```http
+POST /api/scene/{scene_name}/activate
+```
+
+Example:
+```bash
+curl -X POST http://localhost:3000/api/scene/movie_night/activate \
+  -H "Authorization: Bearer YOUR_JWT_TOKEN"
+```
+
+## Groups
+
+### Create Device Group
+
+Create a group of devices for collective control.
+
+```http
+POST /api/group
+```
+
+Request body:
+```json
+{
+  "name": "Living Room",
+  "entities": [
+    "light.living_room_main",
+    "light.living_room_accent",
+    "switch.living_room_fan"
+  ]
+}
+```
+
+### Control Group
+
+Control multiple devices in a group.
+
+```http
+POST /api/group/{group_name}/control
+```
+
+Request body:
+```json
+{
+  "action": "turn_off"
+}
+```
+
+## System Operations
+
+### Health Check
+
+Check server status and connectivity.
+
+```http
+GET /health
+```
+
+Response:
+```json
+{
+  "status": "healthy",
+  "version": "1.0.0",
+  "uptime": 3600,
+  "homeAssistant": {
+    "connected": true,
+    "version": "2024.1.0"
+  }
+}
+```
+
+### Configuration
+
+Get current server configuration.
+
+```http
+GET /api/config
+```
+
+Response:
+```json
+{
+  "server": {
+    "port": 3000,
+    "host": "0.0.0.0",
+    "version": "1.0.0"
+  },
+  "homeAssistant": {
+    "url": "http://homeassistant:8123",
+    "connected": true
+  },
+  "features": {
+    "nlp": true,
+    "scenes": true,
+    "groups": true
+  }
+}
+```
+
+## Error Handling
+
+All endpoints follow standard HTTP status codes and return detailed error messages:
+
+```json
+{
+  "error": true,
+  "code": "INVALID_ENTITY",
+  "message": "Device 'light.nonexistent' not found",
+  "details": {
+    "entity_id": "light.nonexistent",
+    "available_entities": [
+      "light.living_room",
+      "light.kitchen"
+    ]
+  }
+}
+```
+
+Common error codes:
+- `INVALID_ENTITY`: Device not found
+- `INVALID_ACTION`: Unsupported action
+- `INVALID_PARAMETERS`: Invalid command parameters
+- `AUTHENTICATION_ERROR`: Invalid or missing token
+- `CONNECTION_ERROR`: Home Assistant connection issue
+
+## TypeScript Interfaces
+
+```typescript
+interface DeviceState {
+  entity_id: string;
+  state: string;
+  attributes: Record<string, any>;
+  last_changed: string;
+}
+
+interface DeviceCommand {
+  entity_id: string;
+  action: 'turn_on' | 'turn_off' | 'toggle' | 'set_value';
+  parameters?: Record<string, any>;
+}
+
+interface Scene {
+  name: string;
+  description?: string;
+  actions: DeviceCommand[];
+}
+
+interface Group {
+  name: string;
+  entities: string[];
+}
+```
+
+## Related Resources
+
+- [API Overview](index.md)
+- [SSE API](sse.md)
+- [Architecture](../architecture.md)
+- [Examples](https://github.com/jango-blockchained/advanced-homeassistant-mcp/tree/main/examples) 

docs/api/index.md

@@ -0,0 +1,234 @@
+---
+layout: default
+title: API Overview
+parent: API Reference
+nav_order: 1
+has_children: false
+---
+
+# API Documentation 📚
+
+Welcome to the MCP Server API documentation. This guide covers all available endpoints, authentication methods, and integration patterns.
+
+## API Overview
+
+The MCP Server provides several API categories:
+
+1. **Core API** - Basic device control and state management
+2. **SSE API** - Real-time event subscriptions
+3. **Scene API** - Scene management and automation
+4. **Voice API** - Natural language command processing
+
+## Authentication
+
+All API endpoints require authentication using JWT tokens:
+
+```bash
+# Include the token in your requests
+curl -H "Authorization: Bearer YOUR_JWT_TOKEN" http://localhost:3000/api/state
+```
+
+To obtain a token:
+
+```bash
+curl -X POST http://localhost:3000/auth/token \
+  -H "Content-Type: application/json" \
+  -d '{"username": "your_username", "password": "your_password"}'
+```
+
+## Core Endpoints
+
+### Device State
+
+```http
+GET /api/state
+```
+
+Retrieve the current state of all devices:
+
+```bash
+curl http://localhost:3000/api/state
+```
+
+Response:
+```json
+{
+  "devices": [
+    {
+      "id": "light.living_room",
+      "state": "on",
+      "attributes": {
+        "brightness": 255,
+        "color_temp": 370
+      }
+    }
+  ]
+}
+```
+
+### Command Execution
+
+```http
+POST /api/command
+```
+
+Execute a natural language command:
+
+```bash
+curl -X POST http://localhost:3000/api/command \
+  -H "Content-Type: application/json" \
+  -d '{"command": "Turn on the kitchen lights"}'
+```
+
+Response:
+```json
+{
+  "success": true,
+  "action": "turn_on",
+  "device": "light.kitchen",
+  "message": "Kitchen lights turned on"
+}
+```
+
+## Real-Time Events
+
+### Event Subscription
+
+```http
+GET /subscribe_events
+```
+
+Subscribe to device state changes:
+
+```javascript
+const eventSource = new EventSource('http://localhost:3000/subscribe_events?token=YOUR_TOKEN');
+
+eventSource.onmessage = (event) => {
+    const data = JSON.parse(event.data);
+    console.log('State changed:', data);
+};
+```
+
+### Filtered Subscriptions
+
+Subscribe to specific device types:
+
+```http
+GET /subscribe_events?domain=light
+GET /subscribe_events?entity_id=light.living_room
+```
+
+## Scene Management
+
+### Create Scene
+
+```http
+POST /api/scene
+```
+
+Create a new scene:
+
+```bash
+curl -X POST http://localhost:3000/api/scene \
+  -H "Content-Type: application/json" \
+  -d '{
+    "name": "Movie Night",
+    "actions": [
+      {"device": "light.living_room", "action": "dim", "value": 20},
+      {"device": "media_player.tv", "action": "on"}
+    ]
+  }'
+```
+
+### Activate Scene
+
+```http
+POST /api/scene/activate
+```
+
+Activate an existing scene:
+
+```bash
+curl -X POST http://localhost:3000/api/scene/activate \
+  -H "Content-Type: application/json" \
+  -d '{"name": "Movie Night"}'
+```
+
+## Error Handling
+
+The API uses standard HTTP status codes:
+
+- `200` - Success
+- `400` - Bad Request
+- `401` - Unauthorized
+- `404` - Not Found
+- `500` - Server Error
+
+Error responses include detailed messages:
+
+```json
+{
+  "error": true,
+  "message": "Device not found",
+  "code": "DEVICE_NOT_FOUND",
+  "details": {
+    "device_id": "light.nonexistent"
+  }
+}
+```
+
+## Rate Limiting
+
+API requests are rate-limited to prevent abuse:
+
+```http
+X-RateLimit-Limit: 100
+X-RateLimit-Remaining: 99
+X-RateLimit-Reset: 1640995200
+```
+
+When exceeded, returns `429 Too Many Requests`:
+
+```json
+{
+  "error": true,
+  "message": "Rate limit exceeded",
+  "reset": 1640995200
+}
+```
+
+## WebSocket API
+
+For bi-directional communication:
+
+```javascript
+const ws = new WebSocket('ws://localhost:3000/ws');
+
+ws.onmessage = (event) => {
+    const data = JSON.parse(event.data);
+    console.log('Received:', data);
+};
+
+ws.send(JSON.stringify({
+    type: 'command',
+    payload: {
+        command: 'Turn on lights'
+    }
+}));
+```
+
+## API Versioning
+
+The current API version is v1. Include the version in the URL:
+
+```http
+/api/v1/state
+/api/v1/command
+```
+
+## Further Reading
+
+- [SSE API Details](sse.md) - In-depth SSE documentation
+- [Core Functions](core.md) - Detailed endpoint documentation
+- [Architecture Overview](../architecture.md) - System design details
+- [Troubleshooting](../troubleshooting.md) - Common issues and solutions 

docs/api/sse.md

@@ -0,0 +1,266 @@
+---
+layout: default
+title: SSE API
+parent: API Reference
+nav_order: 2
+---
+
+# Server-Sent Events (SSE) API 📡
+
+The SSE API provides real-time updates about device states and events from your Home Assistant setup. This guide covers how to use and implement SSE connections in your applications.
+
+## Overview
+
+Server-Sent Events (SSE) is a standard that enables servers to push real-time updates to clients over HTTP connections. MCP Server uses SSE to provide:
+
+- Real-time device state updates
+- Event notifications
+- System status changes
+- Command execution results
+
+## Basic Usage
+
+### Establishing a Connection
+
+Create an EventSource connection to receive updates:
+
+```javascript
+const eventSource = new EventSource('http://localhost:3000/subscribe_events?token=YOUR_JWT_TOKEN');
+
+eventSource.onmessage = (event) => {
+    const data = JSON.parse(event.data);
+    console.log('Received update:', data);
+};
+```
+
+### Connection States
+
+Handle different connection states:
+
+```javascript
+eventSource.onopen = () => {
+    console.log('Connection established');
+};
+
+eventSource.onerror = (error) => {
+    console.error('Connection error:', error);
+    // Implement reconnection logic if needed
+};
+```
+
+## Event Types
+
+### Device State Events
+
+Subscribe to all device state changes:
+
+```javascript
+const stateEvents = new EventSource('http://localhost:3000/subscribe_events?type=state');
+
+stateEvents.onmessage = (event) => {
+    const state = JSON.parse(event.data);
+    console.log('Device state changed:', state);
+};
+```
+
+Example state event:
+```json
+{
+  "type": "state_changed",
+  "entity_id": "light.living_room",
+  "state": "on",
+  "attributes": {
+    "brightness": 255,
+    "color_temp": 370
+  },
+  "timestamp": "2024-01-20T15:30:00Z"
+}
+```
+
+### Filtered Subscriptions
+
+#### By Domain
+Subscribe to specific device types:
+
+```javascript
+// Subscribe to only light events
+const lightEvents = new EventSource('http://localhost:3000/subscribe_events?domain=light');
+
+// Subscribe to multiple domains
+const multiEvents = new EventSource('http://localhost:3000/subscribe_events?domain=light,switch,sensor');
+```
+
+#### By Entity ID
+Subscribe to specific devices:
+
+```javascript
+// Single entity
+const livingRoomLight = new EventSource(
+    'http://localhost:3000/subscribe_events?entity_id=light.living_room'
+);
+
+// Multiple entities
+const kitchenDevices = new EventSource(
+    'http://localhost:3000/subscribe_events?entity_id=light.kitchen,switch.coffee_maker'
+);
+```
+
+## Advanced Usage
+
+### Connection Management
+
+Implement robust connection handling:
+
+```javascript
+class SSEManager {
+    constructor(url, options = {}) {
+        this.url = url;
+        this.options = {
+            maxRetries: 3,
+            retryDelay: 1000,
+            ...options
+        };
+        this.retryCount = 0;
+        this.connect();
+    }
+
+    connect() {
+        this.eventSource = new EventSource(this.url);
+        
+        this.eventSource.onopen = () => {
+            this.retryCount = 0;
+            console.log('Connected to SSE stream');
+        };
+
+        this.eventSource.onerror = (error) => {
+            this.handleError(error);
+        };
+
+        this.eventSource.onmessage = (event) => {
+            this.handleMessage(event);
+        };
+    }
+
+    handleError(error) {
+        console.error('SSE Error:', error);
+        this.eventSource.close();
+
+        if (this.retryCount < this.options.maxRetries) {
+            this.retryCount++;
+            setTimeout(() => {
+                console.log(`Retrying connection (${this.retryCount}/${this.options.maxRetries})`);
+                this.connect();
+            }, this.options.retryDelay * this.retryCount);
+        }
+    }
+
+    handleMessage(event) {
+        try {
+            const data = JSON.parse(event.data);
+            // Handle the event data
+            console.log('Received:', data);
+        } catch (error) {
+            console.error('Error parsing SSE data:', error);
+        }
+    }
+
+    disconnect() {
+        if (this.eventSource) {
+            this.eventSource.close();
+        }
+    }
+}
+
+// Usage
+const sseManager = new SSEManager('http://localhost:3000/subscribe_events?token=YOUR_TOKEN');
+```
+
+### Event Filtering
+
+Filter events on the client side:
+
+```javascript
+class EventFilter {
+    constructor(conditions) {
+        this.conditions = conditions;
+    }
+
+    matches(event) {
+        return Object.entries(this.conditions).every(([key, value]) => {
+            if (Array.isArray(value)) {
+                return value.includes(event[key]);
+            }
+            return event[key] === value;
+        });
+    }
+}
+
+// Usage
+const filter = new EventFilter({
+    domain: ['light', 'switch'],
+    state: 'on'
+});
+
+eventSource.onmessage = (event) => {
+    const data = JSON.parse(event.data);
+    if (filter.matches(data)) {
+        console.log('Matched event:', data);
+    }
+};
+```
+
+## Best Practices
+
+1. **Authentication**
+   - Always include authentication tokens
+   - Implement token refresh mechanisms
+   - Handle authentication errors gracefully
+
+2. **Error Handling**
+   - Implement progressive retry logic
+   - Log connection issues
+   - Notify users of connection status
+
+3. **Resource Management**
+   - Close EventSource connections when not needed
+   - Limit the number of concurrent connections
+   - Use filtered subscriptions when possible
+
+4. **Performance**
+   - Process events efficiently
+   - Batch UI updates
+   - Consider debouncing frequent updates
+
+## Common Issues
+
+### Connection Drops
+If the connection drops, the EventSource will automatically attempt to reconnect. You can customize this behavior:
+
+```javascript
+eventSource.addEventListener('error', (error) => {
+    if (eventSource.readyState === EventSource.CLOSED) {
+        // Connection closed, implement custom retry logic
+    }
+});
+```
+
+### Memory Leaks
+Always clean up EventSource connections:
+
+```javascript
+// In a React component
+useEffect(() => {
+    const eventSource = new EventSource('http://localhost:3000/subscribe_events');
+    
+    return () => {
+        eventSource.close(); // Cleanup on unmount
+    };
+}, []);
+```
+
+## Related Resources
+
+- [API Overview](index.md)
+- [Core Functions](core.md)
+- [WebSocket API](index.md#websocket-api)
+- [Troubleshooting](../troubleshooting.md) 

docs/architecture.md

@@ -1,68 +1,283 @@
-# Architecture Documentation for MCP Server
+---
+layout: default
+title: Architecture
+nav_order: 4
+---
 
-## Overview
+# Architecture Overview 🏗️
 
-The MCP Server is designed as a high-performance, secure, and scalable bridge between Home Assistant and Language Learning Models (LLMs). This document outlines the architectural design principles, core components, and deployment strategies that power the MCP Server.
+This document describes the architecture of the MCP Server, explaining how different components work together to provide a bridge between Home Assistant and Language Learning Models.
 
-## Key Architectural Components
+## System Architecture
 
-### High-Performance Runtime with Bun
+```mermaid
+graph TD
+    subgraph "Client Layer"
+        WC[Web Clients]
+        MC[Mobile Clients]
+        VC[Voice Assistants]
+    end
 
-- **Fast Startup & Efficiency:** Powered by Bun, the MCP Server benefits from rapid startup times, efficient memory utilization, and native TypeScript support.
+    subgraph "MCP Server"
-- **Optimized Build Process:** Bun's build tools allow for quick iteration and deployment, ensuring minimal downtime and swift performance enhancement.
+        API[API Gateway]
+        NLP[NLP Engine]
+        SSE[SSE Manager]
+        WS[WebSocket Server]
+        CM[Command Manager]
+        SC[Scene Controller]
+        Cache[Redis Cache]
+    end
 
-### Real-time Communication using Server-Sent Events (SSE)
+    subgraph "Home Assistant"
+        HA[Home Assistant Core]
+        Dev[Devices & Services]
+    end
 
-- **Continuous Updates:** The server leverages SSE to deliver real-time notifications and updates, ensuring that any changes in Home Assistant are immediately communicated to connected clients.
+    subgraph "AI Layer"
-- **Scalable Connection Handling:** SSE provides an event-driven model that efficiently manages multiple simultaneous client connections.
+        LLM[Language Models]
+        IC[Intent Classifier]
+        NER[Named Entity Recognition]
+    end
 
-### Modular & Extensible Design
+    WC --> |HTTP/WS| API
+    MC --> |HTTP/WS| API
+    VC --> |HTTP| API
+    
+    API --> |Events| SSE
+    API --> |Real-time| WS
+    API --> |Process| NLP
+    
+    NLP --> |Query| LLM
+    NLP --> |Extract| IC
+    NLP --> |Identify| NER
+    
+    CM --> |Execute| HA
+    HA --> |Control| Dev
+    
+    SSE --> |State Updates| WC
+    SSE --> |State Updates| MC
+    WS --> |Bi-directional| WC
+    
+    Cache --> |Fast Access| API
+    HA --> |Events| Cache
+```
 
-- **Plugin Architecture:** Designed with modularity in mind, the MCP Server supports plugins, add-ons, and custom automation scripts, enabling seamless feature expansion without disrupting core functionality.
+## Component Details
-- **Separation of Concerns:** Different components, such as device management, automation control, and system monitoring, are clearly separated, allowing independent development, testing, and scaling.
 
-### Secure API Integration
+### 1. Client Layer
 
-- **Token-Based Authentication:** Robust token-based authentication mechanisms restrict access to authorized users and systems.
+The client layer consists of various interfaces that interact with the MCP Server:
-- **Rate Limiting & Error Handling:** Integrated rate limiting combined with comprehensive error handling ensures system stability and prevents misuse.
-- **Best Practices:** All API endpoints follow industry-standard security guidelines to protect data and maintain system integrity.
 
-### Deployment & Scalability
+- **Web Clients**: Browser-based dashboards and control panels
+- **Mobile Clients**: Native mobile applications
+- **Voice Assistants**: Voice-enabled devices and interfaces
 
-- **Containerized Deployment with Docker:** The use of Docker Compose enables straightforward deployment, management, and scaling of the server and its dependencies.
+### 2. MCP Server Core
-- **Flexible Environment Configuration:** Environment variables and configuration files (.env) facilitate smooth transitions between development, testing, and production setups.
 
-## Future Enhancements
+#### API Gateway
+- Handles all incoming HTTP requests
+- Manages authentication and rate limiting
+- Routes requests to appropriate handlers
 
-- **Advanced Automation Logic:** Integration of more complex automation rules and conditional decision-making capabilities.
+```typescript
-- **Enhanced Security Measures:** Additional layers of security, such as multi-factor authentication and improved encryption techniques, are on the roadmap.
+interface APIGateway {
-- **Improved Monitoring & Analytics:** Future updates will introduce advanced performance metrics and real-time analytics to monitor system health and user interactions.
+    authenticate(): Promise<boolean>;
+    rateLimit(): Promise<boolean>;
+    route(request: Request): Promise<Response>;
+}
+```
 
-## Conclusion
+#### NLP Engine
+- Processes natural language commands
+- Integrates with Language Models
+- Extracts intents and entities
 
-The architecture of the MCP Server prioritizes performance, scalability, and security. By leveraging Bun's high-performance runtime, employing real-time communication through SSE, and maintaining a modular, secure design, the MCP Server provides a robust platform for integrating Home Assistant with modern LLM functionalities.
+```typescript
+interface NLPEngine {
+    processCommand(text: string): Promise<CommandIntent>;
+    extractEntities(text: string): Promise<Entity[]>;
+    validateIntent(intent: CommandIntent): boolean;
+}
+```
 
-*This document is a living document and will be updated as the system evolves.* 
+#### Event Management
+- **SSE Manager**: Handles Server-Sent Events
+- **WebSocket Server**: Manages bi-directional communication
+- **Command Manager**: Processes and executes commands
 
-## Key Components
+### 3. Home Assistant Integration
 
-- **API Module:** Handles RESTful endpoints, authentication, and error management.
+The server maintains a robust connection to Home Assistant through:
-- **SSE Module:** Provides real-time updates through Server-Sent Events.
+
-- **Tools Module:** Offers various utilities for device control, automation, and data processing.
+- REST API calls
-- **Security Module:** Implements token-based authentication and secure communications.
+- WebSocket connections
-- **Integration Module:** Bridges data between Home Assistant and external systems.
+- Event subscriptions
+
+```typescript
+interface HomeAssistantClient {
+    connect(): Promise<void>;
+    getState(entityId: string): Promise<EntityState>;
+    executeCommand(command: Command): Promise<CommandResult>;
+    subscribeToEvents(callback: EventCallback): Subscription;
+}
+```
+
+### 4. AI Layer
+
+#### Language Model Integration
+- Processes natural language input
+- Understands context and user intent
+- Generates appropriate responses
+
+#### Intent Classification
+- Identifies command types
+- Extracts parameters
+- Validates requests
 
 ## Data Flow
 
-1. Requests enter via the API endpoints.
+### 1. Command Processing
-2. Security middleware validates and processes requests.
-3. Core modules process data and execute the necessary business logic.
-4. Real-time notifications are managed by the SSE module.
 
-## Future Enhancements
+```mermaid
+sequenceDiagram
+    participant Client
+    participant API
+    participant NLP
+    participant LLM
+    participant HA
+    
+    Client->>API: Send command
+    API->>NLP: Process text
+    NLP->>LLM: Get intent
+    LLM-->>NLP: Return structured intent
+    NLP->>HA: Execute command
+    HA-->>API: Return result
+    API-->>Client: Send response
+```
 
-- Expand modularity with potential microservices.
+### 2. Real-time Updates
-- Enhance security with multi-factor authentication.
-- Improve scalability through distributed architectures.
 
-*Further diagrams and detailed breakdowns will be added in future updates.* 
+```mermaid
+sequenceDiagram
+    participant HA
+    participant Cache
+    participant SSE
+    participant Client
+    
+    HA->>Cache: State change
+    Cache->>SSE: Notify change
+    SSE->>Client: Send update
+    Note over Client: Update UI
+```
+
+### 3. [SSE API](api/sse.md)
+- Event Subscriptions
+- Real-time Updates
+- Connection Management
+
+## Security Architecture
+
+### Authentication Flow
+
+1. **JWT-based Authentication**
+   ```typescript
+   interface AuthToken {
+       token: string;
+       expires: number;
+       scope: string[];
+   }
+   ```
+
+2. **Rate Limiting**
+   ```typescript
+   interface RateLimit {
+       window: number;
+       max: number;
+       current: number;
+   }
+   ```
+
+### Security Measures
+
+- TLS encryption for all communications
+- Input sanitization
+- Request validation
+- Token-based authentication
+- Rate limiting
+- IP filtering
+
+## Performance Optimizations
+
+### Caching Strategy
+
+```mermaid
+graph LR
+    Request --> Cache{Cache?}
+    Cache -->|Hit| Response
+    Cache -->|Miss| HA[Home Assistant]
+    HA --> Cache
+    Cache --> Response
+```
+
+### Connection Management
+
+- Connection pooling
+- Automatic reconnection
+- Load balancing
+- Request queuing
+
+## Configuration
+
+The system is highly configurable through environment variables and configuration files:
+
+```yaml
+server:
+  port: 3000
+  host: '0.0.0.0'
+  
+homeAssistant:
+  url: 'http://homeassistant:8123'
+  token: 'YOUR_TOKEN'
+  
+security:
+  jwtSecret: 'your-secret'
+  rateLimit: 100
+  
+ai:
+  model: 'gpt-4'
+  temperature: 0.7
+  
+cache:
+  ttl: 300
+  maxSize: '100mb'
+```
+
+## Deployment Architecture
+
+### Docker Deployment
+
+```mermaid
+graph TD
+    subgraph "Docker Compose"
+        MCP[MCP Server]
+        Redis[Redis Cache]
+        HA[Home Assistant]
+    end
+    
+    MCP --> Redis
+    MCP --> HA
+```
+
+### Scaling Considerations
+
+- Horizontal scaling capabilities
+- Load balancing support
+- Redis cluster support
+- Multiple HA instance support
+
+## Further Reading
+
+- [API Documentation](api/index.md)
+- [Installation Guide](getting-started/installation.md)
+- [Contributing Guidelines](contributing.md)
+- [Troubleshooting](troubleshooting.md) 

docs/assets/stylesheets/extra.css

@@ -0,0 +1,28 @@
+:root {
+  --md-primary-fg-color: #1a73e8;
+  --md-primary-fg-color--light: #5195ee;
+  --md-primary-fg-color--dark: #0d47a1;
+}
+
+.md-header {
+  box-shadow: 0 0 0.2rem rgba(0,0,0,.1), 0 0.2rem 0.4rem rgba(0,0,0,.2);
+}
+
+.md-main__inner {
+  margin-top: 1.5rem;
+}
+
+.md-typeset h1 {
+  font-weight: 700;
+  color: var(--md-primary-fg-color);
+}
+
+.md-typeset .admonition {
+  font-size: .8rem;
+}
+
+code {
+  background-color: rgba(175,184,193,0.2);
+  padding: .2em .4em;
+  border-radius: 6px;
+} 

docs/contributing.md

@@ -1,36 +1,254 @@
-# Contributing to Home Assistant MCP
+---
+layout: default
+title: Contributing
+nav_order: 5
+---
 
-We welcome community contributions to improve the MCP Server. Please review the following guidelines before contributing.
+# Contributing Guide 🤝
 
-## How to Contribute
+Thank you for your interest in contributing to the MCP Server project! This guide will help you get started with contributing to the project.
 
-1. **Fork the Repository:** Create your personal fork on GitHub.
+## Getting Started
-2. **Create a Feature Branch:** Use a clear name (e.g., `feature/your-feature` or `bugfix/short-description`).
-3. **Make Changes:** Develop your feature or fix bugs while following our coding standards.
-4. **Write Tests:** Include tests for new features or bug fixes.
-5. **Submit a Pull Request:** Once your changes are complete, submit a PR for review.
-6. **Address Feedback:** Revise your PR based on maintainers' suggestions.
 
-## Code Style Guidelines
+### Prerequisites
 
-- Follow the project's established coding style.
+Before you begin, ensure you have:
-- Use Bun tooling for linting and formatting:
+
-  - `bun run lint`
+- [Bun](https://bun.sh) >= 1.0.26
-  - `bun run format`
+- [Node.js](https://nodejs.org) >= 18
+- [Docker](https://www.docker.com) (optional, for containerized development)
+- A running Home Assistant instance for testing
+
+### Development Setup
+
+1. Fork and clone the repository:
+   ```bash
+   git clone https://github.com/YOUR_USERNAME/advanced-homeassistant-mcp.git
+   cd advanced-homeassistant-mcp
+   ```
+
+2. Install dependencies:
+   ```bash
+   bun install
+   ```
+
+3. Set up your development environment:
+   ```bash
+   cp .env.example .env
+   # Edit .env with your Home Assistant details
+   ```
+
+4. Start the development server:
+   ```bash
+   bun run dev
+   ```
+
+## Development Workflow
+
+### Branch Naming Convention
+
+- `feature/` - New features
+- `fix/` - Bug fixes
+- `docs/` - Documentation updates
+- `refactor/` - Code refactoring
+- `test/` - Test improvements
+
+Example:
+```bash
+git checkout -b feature/voice-commands
+```
+
+### Commit Messages
+
+We follow the [Conventional Commits](https://www.conventionalcommits.org/) specification:
+
+```
+type(scope): description
+
+[optional body]
+
+[optional footer]
+```
+
+Types:
+- `feat:` - New features
+- `fix:` - Bug fixes
+- `docs:` - Documentation changes
+- `style:` - Code style changes (formatting, etc.)
+- `refactor:` - Code refactoring
+- `test:` - Test updates
+- `chore:` - Maintenance tasks
+
+Examples:
+```bash
+feat(api): add voice command endpoint
+fix(sse): resolve connection timeout issue
+docs(readme): update installation instructions
+```
+
+### Testing
+
+Run tests before submitting your changes:
+
+```bash
+# Run all tests
+bun test
+
+# Run specific test file
+bun test test/api/command.test.ts
+
+# Run tests with coverage
+bun test --coverage
+```
+
+### Code Style
+
+We use ESLint and Prettier for code formatting:
+
+```bash
+# Check code style
+bun run lint
+
+# Fix code style issues
+bun run lint:fix
+```
+
+## Pull Request Process
+
+1. **Update Documentation**
+   - Add/update relevant documentation
+   - Include inline code comments where necessary
+   - Update API documentation if endpoints change
+
+2. **Write Tests**
+   - Add tests for new features
+   - Update existing tests if needed
+   - Ensure all tests pass
+
+3. **Create Pull Request**
+   - Fill out the PR template
+   - Link related issues
+   - Provide clear description of changes
+
+4. **Code Review**
+   - Address review comments
+   - Keep discussions focused
+   - Be patient and respectful
+
+### PR Template
+
+```markdown
+## Description
+Brief description of the changes
+
+## Type of Change
+- [ ] Bug fix
+- [ ] New feature
+- [ ] Breaking change
+- [ ] Documentation update
+
+## How Has This Been Tested?
+Describe your test process
+
+## Checklist
+- [ ] Tests added/updated
+- [ ] Documentation updated
+- [ ] Code follows style guidelines
+- [ ] All tests passing
+```
+
+## Development Guidelines
+
+### Code Organization
+
+```
+src/
+├── api/          # API endpoints
+├── core/         # Core functionality
+├── models/       # Data models
+├── services/     # Business logic
+├── utils/        # Utility functions
+└── types/        # TypeScript types
+```
+
+### Best Practices
+
+1. **Type Safety**
+   ```typescript
+   // Use explicit types
+   interface CommandRequest {
+       command: string;
+       parameters?: Record<string, unknown>;
+   }
+   
+   function processCommand(request: CommandRequest): Promise<CommandResponse> {
+       // Implementation
+   }
+   ```
+
+2. **Error Handling**
+   ```typescript
+   try {
+       await processCommand(request);
+   } catch (error) {
+       if (error instanceof ValidationError) {
+           // Handle validation errors
+       }
+       throw error;
+   }
+   ```
+
+3. **Async/Await**
+   ```typescript
+   // Prefer async/await over promises
+   async function handleRequest() {
+       const result = await processData();
+       return result;
+   }
+   ```
 
 ## Documentation
 
-- Update documentation alongside your code changes.
+### API Documentation
-- Ensure tests pass and coverage remains high.
 
-## Reporting Issues
+Update API documentation when adding/modifying endpoints:
 
-- Use the GitHub Issues page to report bugs, request new features, or ask questions.
+```typescript
-- Provide clear descriptions, replication steps, and any error logs.
+/**
+ * Process a voice command
+ * @param command - The voice command to process
+ * @returns Promise<CommandResult>
+ * @throws {ValidationError} If command is invalid
+ */
+async function processVoiceCommand(command: string): Promise<CommandResult> {
+    // Implementation
+}
+```
 
-## Community
+### README Updates
 
-- Join our real-time discussions on our chat platforms (Discord, Slack, etc.).
+Keep the README up to date with:
-- Engage with other contributors to exchange ideas and solutions.
+- New features
+- Changed requirements
+- Updated examples
+- Modified configuration
 
-Thank you for helping improve the Home Assistant MCP project! 
+## Getting Help
+
+- Check [Discussions](https://github.com/jango-blockchained/advanced-homeassistant-mcp/discussions)
+- Review existing [Issues](https://github.com/jango-blockchained/advanced-homeassistant-mcp/issues)
+
+## Community Guidelines
+
+We expect all contributors to:
+
+- Be respectful and inclusive
+- Focus on constructive feedback
+- Help maintain a positive environment
+- Follow our code style guidelines
+- Write clear documentation
+- Test their code thoroughly
+
+## License
+
+By contributing, you agree that your contributions will be licensed under the MIT License. 

docs/examples/index.md

@@ -0,0 +1,22 @@
+---
+layout: default
+title: Examples
+nav_order: 7
+has_children: true
+---
+
+# Example Projects 📚
+
+This section contains examples and tutorials for common MCP Server integrations.
+
+## Speech-to-Text Integration
+
+Example of integrating speech recognition with MCP Server:
+
+```typescript
+// From examples/speech-to-text-example.ts
+// Add example code and explanation
+```
+
+## More Examples Coming Soon
+... 

docs/getting-started/docker.md

@@ -0,0 +1,10 @@
+---
+layout: default
+title: Docker Deployment
+parent: Getting Started
+nav_order: 3
+---
+
+# Docker Deployment Guide 🐳
+
+Detailed guide for deploying MCP Server with Docker... 

docs/getting-started/installation.md

@@ -1,124 +1,181 @@
-# Installation Guide
+---
+layout: default
+title: Installation
+parent: Getting Started
+nav_order: 1
+---
+
+# Installation Guide 🛠️
+
+This guide covers different methods to install and set up the MCP Server for Home Assistant. Choose the installation method that best suits your needs.
 
 ## Prerequisites
 
-### System Requirements
+Before installing MCP Server, ensure you have:
-- **Operating System:** Linux, macOS, or Windows (Docker recommended)
-- **Runtime:** Bun v1.0.26 or higher
-- **Home Assistant:** v2023.11 or higher
-- **Minimum Hardware:**
-  - 2 CPU cores
-  - 2GB RAM
-  - 10GB free disk space
 
-### Software Dependencies
+- Home Assistant instance running and accessible
-- Bun runtime
+- Node.js 18+ or Docker installed
-- Docker (optional, recommended for deployment)
+- Home Assistant Long-Lived Access Token ([How to get one](https://developers.home-assistant.io/docs/auth_api/#long-lived-access-token))
-- Git
-- Node.js (for some development tasks)
 
 ## Installation Methods
 
-### 1. Basic Setup
+### 1. 🔧 Smithery Installation (Recommended)
 
-#### Install Bun
+The easiest way to install MCP Server is through Smithery:
-```bash
+
-curl -fsSL https://bun.sh/install | bash
+#### Smithery Configuration
+
+The project includes a `smithery.yaml` configuration:
+
+```yaml
+# Add smithery.yaml contents and explanation
 ```
 
-#### Clone Repository
+#### Installation Steps
+
 ```bash
-git clone https://github.com/jango-blockchained/homeassistant-mcp.git
+npx -y @smithery/cli install @jango-blockchained/advanced-homeassistant-mcp --client claude
-cd homeassistant-mcp
 ```
 
-#### Install Dependencies
+### 2. 🐳 Docker Installation
-```bash
+
-bun install
+For a containerized deployment:
-```
 
-#### Configure Environment
-1. Copy environment template
 ```bash
+# Clone the repository
+git clone --depth 1 https://github.com/jango-blockchained/advanced-homeassistant-mcp.git
+cd advanced-homeassistant-mcp
+
+# Configure environment variables
 cp .env.example .env
-```
+# Edit .env with your Home Assistant details:
-2. Edit `.env` file with your Home Assistant configuration
+# - HA_URL: Your Home Assistant URL
-   - Set `HASS_HOST`
+# - HA_TOKEN: Your Long-Lived Access Token
-   - Configure authentication tokens
+# - Other configuration options
-   - Adjust other settings as needed
 
-#### Build and Start
+# Build and start containers
-```bash
+docker compose up -d --build
-bun run build
+
-bun start
+# View logs (optional)
+docker compose logs -f --tail=50
 ```
 
-### 2. Docker Setup (Recommended)
+### 3. 💻 Manual Installation
 
-#### Prerequisites
+For direct installation on your system:
-- Docker
-- Docker Compose
 
-#### Deployment Steps
 ```bash
-# Clone repository
+# Install Bun runtime
-git clone https://github.com/jango-blockchained/homeassistant-mcp.git
+curl -fsSL https://bun.sh/install | bash
-cd homeassistant-mcp
+
+# Clone and install
+git clone https://github.com/jango-blockchained/advanced-homeassistant-mcp.git
+cd advanced-homeassistant-mcp
+bun install --frozen-lockfile
 
 # Configure environment
 cp .env.example .env
-# Edit .env file with your settings
+# Edit .env with your configuration
 
-# Deploy with Docker Compose
+# Start the server
-docker compose up -d
+bun run dev --watch
 ```
 
-### 3. Home Assistant Add-on (Coming Soon)
+## Configuration
-We're working on a direct Home Assistant add-on for even easier installation.
+
+### Environment Variables
+
+Key configuration options in your `.env` file:
+
+```env
+# Home Assistant Configuration
+HA_URL=http://your-homeassistant:8123
+HA_TOKEN=your_long_lived_access_token
+
+# Server Configuration
+PORT=3000
+HOST=0.0.0.0
+NODE_ENV=production
+
+# Security Settings
+JWT_SECRET=your_secure_jwt_secret
+RATE_LIMIT=100
+```
+
+### Client Integration
+
+#### Cursor Integration
+
+Add to `.cursor/config/config.json`:
+
+```json
+{
+  "mcpServers": {
+    "homeassistant-mcp": {
+      "command": "bun",
+      "args": ["run", "start"],
+      "cwd": "${workspaceRoot}",
+      "env": {
+        "NODE_ENV": "development"
+      }
+    }
+  }
+}
+```
+
+#### Claude Desktop Integration
+
+Add to your Claude configuration:
+
+```json
+{
+  "mcpServers": {
+    "homeassistant-mcp": {
+      "command": "bun",
+      "args": ["run", "start", "--port", "8080"],
+      "env": {
+        "NODE_ENV": "production"
+      }
+    }
+  }
+}
+```
 
 ## Verification
 
-### Check Installation
+To verify your installation:
-- Web Interface: [http://localhost:3000](http://localhost:3000)
-- Logs: `docker compose logs` or check `logs/` directory
 
-### Troubleshooting
+1. Check server status:
-- Ensure all environment variables are correctly set
+   ```bash
-- Check network connectivity to Home Assistant
+   curl http://localhost:3000/health
-- Verify authentication tokens
+   ```
 
-## Updating
+2. Test Home Assistant connection:
+   ```bash
+   curl http://localhost:3000/api/state
+   ```
 
-### Basic Setup
+## Troubleshooting
-```bash
-git pull
-bun install
-bun run build
-bun start
-```
 
-### Docker
+If you encounter issues:
-```bash
-git pull
-docker compose up -d --build
-```
 
-## Uninstallation
+1. Check the [Troubleshooting Guide](../troubleshooting.md)
-
+2. Verify your environment variables
-### Basic Setup
+3. Check server logs:
-```bash
+   ```bash
-cd homeassistant-mcp
+   # For Docker installation
-bun stop  # Stop the application
+   docker compose logs -f
-rm -rf node_modules dist
+   
-```
+   # For manual installation
-
+   bun run dev
-### Docker
+   ```
-```bash
-docker compose down
-docker rmi homeassistant-mcp  # Remove image
-```
 
 ## Next Steps
-- [Configuration Guide](configuration.md)
+
-- [Usage Instructions](../usage.md)
+- Follow the [Quick Start Guide](quickstart.md) to begin using MCP Server
-- [Troubleshooting](../troubleshooting.md) 
+- Read the [API Documentation](../api/index.md) for integration details
+- Check the [Architecture Overview](../architecture.md) to understand the system
+
+## Support
+
+Need help? Check our [Support Resources](../index.md#support) or [open an issue](https://github.com/jango-blockchained/advanced-homeassistant-mcp/issues). 

docs/getting-started/quickstart.md

@@ -0,0 +1,219 @@
+---
+layout: default
+title: Quick Start
+parent: Getting Started
+nav_order: 2
+---
+
+# Quick Start Guide 🚀
+
+This guide will help you get started with MCP Server after installation. We'll cover basic usage, common commands, and simple integrations.
+
+## First Steps
+
+### 1. Verify Connection
+
+After installation, verify your MCP Server is running and connected to Home Assistant:
+
+```bash
+# Check server health
+curl http://localhost:3000/health
+
+# Verify Home Assistant connection
+curl http://localhost:3000/api/state
+```
+
+### 2. Basic Voice Commands
+
+Try these basic voice commands to test your setup:
+
+```bash
+# Example using curl for testing
+curl -X POST http://localhost:3000/api/command \
+  -H "Content-Type: application/json" \
+  -d '{"command": "Turn on the living room lights"}'
+```
+
+Common voice commands:
+- "Turn on/off [device name]"
+- "Set [device] to [value]"
+- "What's the temperature in [room]?"
+- "Is [device] on or off?"
+
+## Real-World Examples
+
+### 1. Smart Lighting Control
+
+```javascript
+// Browser example using fetch
+const response = await fetch('http://localhost:3000/api/command', {
+  method: 'POST',
+  headers: {
+    'Content-Type': 'application/json',
+  },
+  body: JSON.stringify({
+    command: 'Set living room lights to 50% brightness and warm white color'
+  })
+});
+```
+
+### 2. Real-Time Updates
+
+Subscribe to device state changes using Server-Sent Events (SSE):
+
+```javascript
+const eventSource = new EventSource('http://localhost:3000/subscribe_events?token=YOUR_TOKEN&domain=light');
+
+eventSource.onmessage = (event) => {
+    const data = JSON.parse(event.data);
+    console.log('Device state changed:', data);
+    // Update your UI here
+};
+```
+
+### 3. Scene Automation
+
+Create and trigger scenes for different activities:
+
+```javascript
+// Create a "Movie Night" scene
+const createScene = async () => {
+  await fetch('http://localhost:3000/api/scene', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      name: 'Movie Night',
+      actions: [
+        { device: 'living_room_lights', action: 'dim', value: 20 },
+        { device: 'tv', action: 'on' },
+        { device: 'soundbar', action: 'on' }
+      ]
+    })
+  });
+};
+
+// Trigger the scene with voice command:
+// "Hey MCP, activate movie night scene"
+```
+
+## Integration Examples
+
+### 1. Web Dashboard Integration
+
+```javascript
+// React component example
+function SmartHomeControl() {
+    const [devices, setDevices] = useState([]);
+    
+    useEffect(() => {
+        // Subscribe to device updates
+        const events = new EventSource('http://localhost:3000/subscribe_events');
+        events.onmessage = (event) => {
+            const data = JSON.parse(event.data);
+            setDevices(currentDevices => 
+                currentDevices.map(device => 
+                    device.id === data.id ? {...device, ...data} : device
+                )
+            );
+        };
+        
+        return () => events.close();
+    }, []);
+
+    return (
+        <div className="dashboard">
+            {devices.map(device => (
+                <DeviceCard key={device.id} device={device} />
+            ))}
+        </div>
+    );
+}
+```
+
+### 2. Voice Assistant Integration
+
+```typescript
+// Example using speech-to-text with MCP
+async function handleVoiceCommand(audioBlob: Blob) {
+    // First, convert speech to text
+    const text = await speechToText(audioBlob);
+    
+    // Then send command to MCP
+    const response = await fetch('http://localhost:3000/api/command', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ command: text })
+    });
+    
+    return response.json();
+}
+```
+
+## Best Practices
+
+1. **Error Handling**
+   ```javascript
+   try {
+       const response = await fetch('http://localhost:3000/api/command', {
+           method: 'POST',
+           headers: {
+               'Content-Type': 'application/json',
+           },
+           body: JSON.stringify({ command: 'Turn on lights' })
+       });
+       
+       if (!response.ok) {
+           throw new Error(`HTTP error! status: ${response.status}`);
+       }
+       
+       const data = await response.json();
+   } catch (error) {
+       console.error('Error:', error);
+       // Handle error appropriately
+   }
+   ```
+
+2. **Connection Management**
+   ```javascript
+   class MCPConnection {
+       constructor() {
+           this.eventSource = null;
+           this.reconnectAttempts = 0;
+       }
+       
+       connect() {
+           this.eventSource = new EventSource('http://localhost:3000/subscribe_events');
+           this.eventSource.onerror = this.handleError.bind(this);
+       }
+       
+       handleError() {
+           if (this.reconnectAttempts < 3) {
+               setTimeout(() => {
+                   this.reconnectAttempts++;
+                   this.connect();
+               }, 1000 * this.reconnectAttempts);
+           }
+       }
+   }
+   ```
+
+## Next Steps
+
+- Explore the [API Documentation](../api/index.md) for advanced features
+- Learn about [SSE API](../api/sse.md) for real-time updates
+- Check out [Architecture](../architecture.md) for system design details
+- Read the [Contributing Guide](../contributing.md) to get involved
+
+## Troubleshooting
+
+If you encounter issues:
+- Verify your authentication token
+- Check server logs for errors
+- Ensure Home Assistant is accessible
+- Review the [Troubleshooting Guide](../troubleshooting.md)
+
+Need more help? Visit our [Support Resources](../index.md#support). 

docs/index.md

@@ -4,107 +4,52 @@ title: Home
 nav_order: 1
 ---
 
-# 📚 Home Assistant MCP Documentation
+# 🚀 MCP Server for Home Assistant
 
-Welcome to the documentation for the Home Assistant MCP (Model Context Protocol) Server.
+Welcome to the Model Context Protocol (MCP) Server documentation! This guide will help you get started with integrating AI-powered natural language processing into your Home Assistant setup.
 
-## 📑 Documentation Index
+## What is MCP Server?
 
-- [Getting Started Guide](getting-started.md)
+MCP Server is a bridge between Home Assistant and Language Learning Models (LLMs), enabling natural language interactions and real-time automation of your smart devices. It allows you to control your home automation setup using natural language commands while maintaining high performance and security.
-- [API Documentation](api.md)
-- [Troubleshooting](troubleshooting.md)
-- [Contributing Guide](contributing.md)
-
-For project overview, installation, and general information, please see our [main README](../README.md).
-
-## 🔗 Quick Links
-
-- [GitHub Repository](https://github.com/jango-blockchained/homeassistant-mcp)
-- [Issue Tracker](https://github.com/jango-blockchained/homeassistant-mcp/issues)
-- [GitHub Discussions](https://github.com/jango-blockchained/homeassistant-mcp/discussions)
-
-## 📝 License
-
-This project is licensed under the MIT License. See [LICENSE](../LICENSE) for details.
-
-# Model Context Protocol (MCP) Server
-
-## Overview
-
-The Model Context Protocol (MCP) Server is a cutting-edge bridge between Home Assistant and Language Learning Models (LLMs), designed to revolutionize smart home automation and control. This documentation provides comprehensive information about setting up, configuring, and using the Home Assistant MCP.
 
 ## Key Features
 
-### 🏠 Smart Home Integration
+### 🎮 Device Control & Monitoring
-- Natural language control of smart devices
+- Voice-controlled automation
-- Real-time device state monitoring
+- Real-time updates via SSE/WebSocket
-- Advanced automation capabilities
+- Scene-based automation rules
 
-### 🤖 LLM Powered Interactions
+### 🤖 AI-Powered Features
-- Intuitive voice and text-based commands
+- Natural Language Processing (NLP)
-- Context-aware device management
+- Predictive automation
-- Intelligent automation suggestions
+- Anomaly detection
 
-### 🔒 Security & Performance
+### 🛡️ Security & Performance
-- Token-based authentication
+- JWT authentication
-- High-performance Bun runtime
+- Request sanitization
-- Secure, real-time communication protocols
+- Sub-100ms latency
+- Rate limiting
 
-## Documentation
+## Documentation Structure
+
+### Getting Started
+- [Installation Guide](getting-started/installation.md) - Set up MCP Server
+- [Quick Start Tutorial](getting-started/quickstart.md) - Basic usage examples
 
 ### Core Documentation
-1. [Getting Started](getting-started.md)
+- [API Documentation](api/index.md) - Complete API reference
-   - Installation and basic setup
+- [Architecture Overview](architecture.md) - System design and components
-   - Configuration
+- [Contributing Guidelines](contributing.md) - How to contribute
-   - First Steps
+- [Troubleshooting Guide](troubleshooting.md) - Common issues and solutions
 
-2. [API Reference](api.md)
+## Support
-   - REST API Endpoints
-   - Authentication
-   - Error Handling
 
-3. [SSE API](sse-api.md)
+If you need help or want to report issues:
-   - Event Subscriptions
-   - Real-time Updates
-   - Connection Management
 
-### Advanced Topics
+- [GitHub Issues](https://github.com/jango-blockchained/advanced-homeassistant-mcp/issues)
-4. [Architecture](architecture.md)
+- [GitHub Discussions](https://github.com/jango-blockchained/advanced-homeassistant-mcp/discussions)
-   - System Design
+- [Contributing Guidelines](contributing.md)
-   - Components
-   - Data Flow
-
-5. [Configuration](getting-started.md#configuration)
-   - Environment Variables
-   - Security Settings
-   - Performance Tuning
-
-6. [Development Guide](development/development.md)
-   - Project Structure
-   - Contributing Guidelines
-   - Testing
-
-7. [Troubleshooting](troubleshooting.md)
-   - Common Issues
-   - Debugging
-   - FAQ
-
-## Quick Links
-
-- [GitHub Repository](https://github.com/jango-blockchained/homeassistant-mcp)
-- [Issue Tracker](https://github.com/jango-blockchained/homeassistant-mcp/issues)
-- [Contributing Guide](contributing.md)
-- [Roadmap](roadmap.md)
-
-## Community and Support
-
-If you need help or have questions:
-
-1. Check the [Troubleshooting Guide](troubleshooting.md)
-2. Search existing [Issues](https://github.com/jango-blockchained/homeassistant-mcp/issues)
-3. Join our [GitHub Discussions](https://github.com/jango-blockchained/homeassistant-mcp/discussions)
-4. Create a new issue if your problem isn't already reported
 
 ## License
 
-This project is licensed under the MIT License. See [LICENSE](https://github.com/jango-blockchained/homeassistant-mcp/blob/main/LICENSE) for details. 
+This project is licensed under the MIT License. See the [LICENSE](https://github.com/jango-blockchained/advanced-homeassistant-mcp/blob/main/LICENSE) file for details. 

docs/troubleshooting.md

@@ -1,345 +1,315 @@
-# Troubleshooting Guide
+---
+layout: default
+title: Troubleshooting
+nav_order: 6
+---
 
-This guide provides solutions to common issues encountered with the Home Assistant MCP Server.
+# Troubleshooting Guide 🔧
+
+This guide helps you diagnose and resolve common issues with MCP Server.
+
+## Quick Diagnostics
+
+### Health Check
+
+First, verify the server's health:
+
+```bash
+curl http://localhost:3000/health
+```
+
+Expected response:
+```json
+{
+  "status": "healthy",
+  "version": "1.0.0",
+  "uptime": 3600,
+  "homeAssistant": {
+    "connected": true,
+    "version": "2024.1.0"
+  }
+}
+```
 
 ## Common Issues
 
-- **Server Not Starting:**
+### 1. Connection Issues
-  - Verify that all required environment variables are correctly set.
-  - Check for port conflicts or missing dependencies.
-  - Review the server logs for error details.
 
-- **Connection Problems:**
+#### Cannot Connect to MCP Server
-  - Ensure your Home Assistant instance is reachable.
-  - Confirm that the authentication token is valid.
-  - Check network configurations and firewalls.
-
-## Tool Issues
-
-### Tool Not Found
 
 **Symptoms:**
-- "Tool not found" errors or 404 responses.
+- Server not responding
+- Connection refused errors
+- Timeout errors
 
 **Solutions:**
-- Double-check the tool name spelling.
-- Verify that the tool is correctly registered.
-- Review tool imports and documentation.
 
-### Tool Execution Failures
+1. Check if the server is running:
+   ```bash
+   # For Docker installation
+   docker compose ps
+   
+   # For manual installation
+   ps aux | grep mcp
+   ```
+
+2. Verify port availability:
+   ```bash
+   # Check if port is in use
+   netstat -tuln | grep 3000
+   ```
+
+3. Check logs:
+   ```bash
+   # Docker logs
+   docker compose logs mcp
+   
+   # Manual installation logs
+   bun run dev
+   ```
+
+#### Home Assistant Connection Failed
 
 **Symptoms:**
-- Execution errors or timeouts.
+- "Connection Error" in health check
+- Cannot control devices
+- State updates not working
 
 **Solutions:**
-- Validate input parameters.
-- Check and review error logs.
-- Debug the tool implementation.
-- Ensure proper permissions in Home Assistant.
 
-## Debugging Steps
+1. Verify Home Assistant URL and token in `.env`:
-
-### Server Logs
-
-1. Enable debug logging by setting:
    ```env
-   LOG_LEVEL=debug
+   HA_URL=http://homeassistant:8123
+   HA_TOKEN=your_long_lived_access_token
    ```
-2. Check logs:
+
+2. Test Home Assistant connection:
    ```bash
-   npm run logs
+   curl -H "Authorization: Bearer YOUR_HA_TOKEN" \
+        http://your-homeassistant:8123/api/
    ```
-3. Filter errors:
+
+3. Check network connectivity:
    ```bash
-   npm run logs | grep "error"
+   # For Docker setup
+   docker compose exec mcp ping homeassistant
    ```
 
+### 2. Authentication Issues
+
+#### Invalid Token
+
+**Symptoms:**
+- 401 Unauthorized responses
+- "Invalid token" errors
+
+**Solutions:**
+
+1. Generate a new token:
+   ```bash
+   curl -X POST http://localhost:3000/auth/token \
+     -H "Content-Type: application/json" \
+     -d '{"username": "your_username", "password": "your_password"}'
+   ```
+
+2. Verify token format:
+   ```javascript
+   // Token should be in format:
+   Authorization: Bearer eyJhbGciOiJIUzI1NiIs...
+   ```
+
+#### Rate Limiting
+
+**Symptoms:**
+- 429 Too Many Requests
+- "Rate limit exceeded" errors
+
+**Solutions:**
+
+1. Check current rate limit status:
+   ```bash
+   curl -I http://localhost:3000/api/state
+   ```
+
+2. Adjust rate limits in configuration:
+   ```yaml
+   security:
+     rateLimit: 100  # Increase if needed
+     rateLimitWindow: 60000  # Window in milliseconds
+   ```
+
+### 3. Real-time Updates Issues
+
+#### SSE Connection Drops
+
+**Symptoms:**
+- Frequent disconnections
+- Missing state updates
+- EventSource errors
+
+**Solutions:**
+
+1. Implement proper reconnection logic:
+   ```javascript
+   class SSEClient {
+       constructor() {
+           this.connect();
+       }
+   
+       connect() {
+           this.eventSource = new EventSource('/subscribe_events');
+           this.eventSource.onerror = this.handleError.bind(this);
+       }
+   
+       handleError(error) {
+           console.error('SSE Error:', error);
+           this.eventSource.close();
+           setTimeout(() => this.connect(), 1000);
+       }
+   }
+   ```
+
+2. Check network stability:
+   ```bash
+   # Monitor connection stability
+   ping -c 100 localhost
+   ```
+
+### 4. Performance Issues
+
+#### High Latency
+
+**Symptoms:**
+- Slow response times
+- Command execution delays
+- UI lag
+
+**Solutions:**
+
+1. Enable Redis caching:
+   ```env
+   REDIS_ENABLED=true
+   REDIS_URL=redis://localhost:6379
+   ```
+
+2. Monitor system resources:
+   ```bash
+   # Check CPU and memory usage
+   docker stats
+   
+   # Or for manual installation
+   top -p $(pgrep -f mcp)
+   ```
+
+3. Optimize database queries and caching:
+   ```typescript
+   // Use batch operations
+   const results = await Promise.all([
+       cache.get('key1'),
+       cache.get('key2')
+   ]);
+   ```
+
+### 5. Device Control Issues
+
+#### Commands Not Executing
+
+**Symptoms:**
+- Commands appear successful but no device response
+- Inconsistent device states
+- Error messages from Home Assistant
+
+**Solutions:**
+
+1. Verify device availability:
+   ```bash
+   curl http://localhost:3000/api/state/light.living_room
+   ```
+
+2. Check command syntax:
+   ```bash
+   # Test basic command
+   curl -X POST http://localhost:3000/api/command \
+     -H "Content-Type: application/json" \
+     -d '{"command": "Turn on living room lights"}'
+   ```
+
+3. Review Home Assistant logs:
+   ```bash
+   docker compose exec homeassistant journalctl -f
+   ```
+
+## Debugging Tools
+
+### Log Analysis
+
+Enable debug logging:
+
+```env
+LOG_LEVEL=debug
+DEBUG=mcp:*
+```
+
 ### Network Debugging
 
-1. Test API endpoints:
+Monitor network traffic:
-   ```bash
-   curl -v http://localhost:3000/api/health
-   ```
-2. Monitor SSE connections:
-   ```bash
-   curl -N http://localhost:3000/api/sse/stats
-   ```
-3. Test WebSocket connectivity:
-   ```bash
-   wscat -c ws://localhost:3000
-   ```
 
-### Performance Issues
+```bash
+# TCP dump for API traffic
+tcpdump -i any port 3000 -w debug.pcap
+```
 
-- Monitor memory usage with:
+### Performance Profiling
-  ```bash
-  npm run stats
-  ```
 
-## Security Middleware Troubleshooting
+Enable performance monitoring:
 
-### Rate Limiting Problems
+```env
-
+ENABLE_METRICS=true
-**Symptoms:** Receiving 429 (Too Many Requests) errors.
+METRICS_PORT=9090
-
+```
-**Solutions:**
-- Adjust and fine-tune rate limit settings.
-- Consider different limits for critical versus non-critical endpoints.
-
-### Request Validation Failures
-
-**Symptoms:** 400 or 415 errors on valid requests.
-
-**Solutions:**
-- Verify that the `Content-Type` header is set correctly.
-- Inspect request payload size and format.
-
-### Input Sanitization Issues
-
-**Symptoms:** Unexpected data transformation or loss.
-
-**Solutions:**
-- Test sanitization with various input types.
-- Implement custom sanitization for complex data if needed.
-
-### Security Header Configuration
-
-**Symptoms:** Missing or improper security headers.
-
-**Solutions:**
-- Review and update security header configurations (e.g., Helmet settings).
-- Ensure environment-specific header settings are in place.
-
-### Error Handling and Logging
-
-**Symptoms:** Inconsistent error responses.
-
-**Solutions:**
-- Enhance logging for detailed error tracking.
-- Adjust error handlers for production and development differences.
-
-## Additional Resources
-
-- [OWASP Security Guidelines](https://owasp.org/www-project-top-ten/)
-- [Helmet.js Documentation](https://helmetjs.github.io/)
-- [JWT Security Best Practices](https://jwt.io/introduction)
 
 ## Getting Help
 
-If issues persist:
+If you're still experiencing issues:
-1. Review detailed logs.
-2. Verify your configuration and environment.
-3. Consult the GitHub issue tracker or community forums.
 
-## FAQ
+1. Check the [GitHub Issues](https://github.com/jango-blockchained/advanced-homeassistant-mcp/issues)
-
+2. Search [Discussions](https://github.com/jango-blockchained/advanced-homeassistant-mcp/discussions)
-### Q: How do I reset my configuration?
+3. Create a new issue with:
-A: Delete `.env` and copy `.env.example` to start fresh.
+   - Detailed description
-
-### Q: Why are my events delayed?
-A: Check network latency and server load. Consider adjusting buffer sizes.
-
-### Q: How do I update my token?
-A: Generate a new token in Home Assistant and update HASS_TOKEN.
-
-### Q: Why do I get "Maximum clients reached"?
-A: Adjust SSE_MAX_CLIENTS in configuration or clean up stale connections.
-
-## Error Codes
-
-- `E001`: Connection Error
-- `E002`: Authentication Error
-- `E003`: Rate Limit Error
-- `E004`: Tool Error
-- `E005`: Configuration Error
-
-## Support Resources
-
-1. Documentation
-   - [API Reference](./API.md)
-   - [Configuration Guide](./configuration/README.md)
-   - [Development Guide](./development/development.md)
-
-2. Community
-   - GitHub Issues
-   - Discussion Forums
-   - Stack Overflow
-
-3. Tools
-   - Diagnostic Scripts
-   - Testing Tools
-   - Monitoring Tools
-
-## Still Need Help?
-
-1. Create a detailed issue:
-   - Error messages
-   - Steps to reproduce
-   - Environment details
    - Logs
+   - Configuration (sanitized)
+   - Steps to reproduce
 
-2. Contact support:
+## Maintenance
-   - GitHub Issues
-   - Email Support
-   - Community Forums
 
-## Security Middleware Troubleshooting
+### Regular Health Checks
 
-### Common Issues and Solutions
+Run periodic health checks:
 
-#### Rate Limiting Problems
+```bash
+# Create a cron job
+*/5 * * * * curl -f http://localhost:3000/health || notify-admin
+```
 
-**Symptom**: Unexpected 429 (Too Many Requests) errors
+### Log Rotation
 
-**Possible Causes**:
+Configure log rotation:
-- Misconfigured rate limit settings
-- Shared IP addresses (e.g., behind NAT)
-- Aggressive client-side retry mechanisms
 
-**Solutions**:
+```yaml
-1. Adjust rate limit parameters
+logging:
-   ```typescript
+  maxSize: "100m"
-   // Customize rate limit for specific scenarios
+  maxFiles: "7d"
-   checkRateLimit(ip, maxRequests = 200, windowMs = 30 * 60 * 1000)
+  compress: true
-   ```
+```
 
-2. Implement more granular rate limiting
+### Backup Configuration
-   - Use different limits for different endpoints
-   - Consider user authentication level
 
-#### Request Validation Failures
+Regularly backup your configuration:
 
-**Symptom**: 400 or 415 status codes on valid requests
+```bash
-
+# Backup script
-**Possible Causes**:
+tar -czf mcp-backup-$(date +%Y%m%d).tar.gz \
-- Incorrect `Content-Type` header
+    .env \
-- Large request payloads
+    config/ \
-- Malformed authorization headers
+    data/
-
+``` 
-**Debugging Steps**:
-1. Verify request headers
-   ```typescript
-   // Check content type and size
-   validateRequestHeaders(request, 'application/json')
-   ```
-
-2. Log detailed validation errors
-   ```typescript
-   try {
-     validateRequestHeaders(request);
-   } catch (error) {
-     console.error('Request validation failed:', error.message);
-   }
-   ```
-
-#### Input Sanitization Issues
-
-**Symptom**: Unexpected data transformation or loss
-
-**Possible Causes**:
-- Complex nested objects
-- Non-standard input formats
-- Overly aggressive sanitization
-
-**Troubleshooting**:
-1. Test sanitization with various input types
-   ```typescript
-   const input = {
-     text: '<script>alert("xss")</script>',
-     nested: { html: '<img src="x" onerror="alert(1)">World' }
-   };
-   const sanitized = sanitizeValue(input);
-   ```
-
-2. Custom sanitization for specific use cases
-   ```typescript
-   function customSanitize(value) {
-     // Add custom sanitization logic
-     return sanitizeValue(value);
-   }
-   ```
-
-#### Security Header Configuration
-
-**Symptom**: Missing or incorrect security headers
-
-**Possible Causes**:
-- Misconfigured Helmet options
-- Environment-specific header requirements
-
-**Solutions**:
-1. Custom security header configuration
-   ```typescript
-   const customHelmetConfig = {
-     contentSecurityPolicy: {
-       directives: {
-         defaultSrc: ["'self'"],
-         scriptSrc: ["'self'", 'trusted-cdn.com']
-       }
-     }
-   };
-   applySecurityHeaders(request, customHelmetConfig);
-   ```
-
-#### Error Handling and Logging
-
-**Symptom**: Inconsistent error responses
-
-**Possible Causes**:
-- Incorrect environment configuration
-- Unhandled error types
-
-**Debugging Techniques**:
-1. Verify environment settings
-   ```typescript
-   const errorResponse = handleError(error, process.env.NODE_ENV);
-   ```
-
-2. Add custom error handling
-   ```typescript
-   function enhancedErrorHandler(error, env) {
-     // Add custom logging or monitoring
-     console.error('Security error:', error);
-     return handleError(error, env);
-   }
-   ```
-
-### Performance and Security Monitoring
-
-1. **Logging**
-   - Enable debug logging for security events
-   - Monitor rate limit and validation logs
-
-2. **Metrics**
-   - Track rate limit hit rates
-   - Monitor request validation success/failure ratios
-
-3. **Continuous Improvement**
-   - Regularly review and update security configurations
-   - Conduct periodic security audits
-
-### Environment-Specific Considerations
-
-#### Development
-- More verbose error messages
-- Relaxed rate limiting
-- Detailed security logs
-
-#### Production
-- Minimal error details
-- Strict rate limiting
-- Comprehensive security headers
-
-### External Resources
-
-- [OWASP Security Guidelines](https://owasp.org/www-project-top-ten/)
-- [Helmet.js Documentation](https://helmetjs.github.io/)
-- [JWT Security Best Practices](https://jwt.io/introduction)
-
-### Getting Help
-
-If you encounter persistent issues:
-1. Check application logs
-2. Verify environment configurations
-3. Consult the project's issue tracker
-4. Reach out to the development team with detailed error information 

mkdocs.yml

@@ -1,26 +1,114 @@
-site_name: Home Assistant Model Context Protocol (MCP)
+site_name: Home Assistant MCP
+site_description: A bridge between Home Assistant and Language Learning Models
 site_url: https://jango-blockchained.github.io/advanced-homeassistant-mcp/
 repo_url: https://github.com/jango-blockchained/advanced-homeassistant-mcp
+repo_name: jango-blockchained/advanced-homeassistant-mcp
 
 theme:
   name: material
+  logo: assets/images/logo.png
+  favicon: assets/images/favicon.ico
+  palette:
+    - media: "(prefers-color-scheme: light)"
+      scheme: default
+      primary: indigo
+      accent: indigo
+      toggle:
+        icon: material/brightness-7
+        name: Switch to dark mode
+    - media: "(prefers-color-scheme: dark)"
+      scheme: slate
+      primary: indigo
+      accent: indigo
+      toggle:
+        icon: material/brightness-4
+        name: Switch to light mode
   features:
-    - navigation.tabs
+    - navigation.instant
+    - navigation.tracking
     - navigation.sections
-    - toc.integrate
+    - navigation.expand
+    - navigation.top
     - search.suggest
     - search.highlight
+    - content.code.copy
 
 markdown_extensions:
-  - pymdownx.highlight
-  - pymdownx.superfences
   - admonition
+  - attr_list
+  - def_list
+  - footnotes
+  - meta
+  - toc:
+      permalink: true
+  - pymdownx.arithmatex:
+      generic: true
+  - pymdownx.betterem:
+      smart_enable: all
+  - pymdownx.caret
   - pymdownx.details
+  - pymdownx.emoji:
+      emoji_index: !!python/name:material.extensions.emoji.twemoji
+      emoji_generator: !!python/name:material.extensions.emoji.to_svg
+  - pymdownx.highlight:
+      anchor_linenums: true
+  - pymdownx.inlinehilite
+  - pymdownx.keys
+  - pymdownx.magiclink
+  - pymdownx.mark
+  - pymdownx.smartsymbols
+  - pymdownx.superfences:
+      custom_fences:
+        - name: mermaid
+          class: mermaid
+          format: !!python/name:pymdownx.superfences.fence_code_format
+  - pymdownx.tabbed:
+      alternate_style: true
+  - pymdownx.tasklist:
+      custom_checkbox: true
+  - pymdownx.tilde
+
+plugins:
+  - search
+  - git-revision-date-localized:
+      type: date
+  - mkdocstrings:
+      default_handler: python
+      handlers:
+        python:
+          options:
+            show_source: true
 
 nav:
   - Home: index.md
   - Getting Started:
     - Installation: getting-started/installation.md
-    - Configuration: getting-started/configuration.md
+    - Quick Start: getting-started/quickstart.md
-  - Usage: usage.md
+  - API Reference:
-  - Contributing: contributing.md 
+    - Overview: api/index.md
+    - SSE API: api/sse.md
+    - Core Functions: api/core.md
+  - Architecture: architecture.md
+  - Contributing: contributing.md
+  - Troubleshooting: troubleshooting.md
+  - Examples:
+    - Overview: examples/index.md
+  - Development:
+    - Setup: development/setup.md
+    - Testing: development/testing.md
+    - CI/CD: development/cicd.md
+
+extra:
+  social:
+    - icon: fontawesome/brands/github
+      link: https://github.com/jango-blockchained/homeassistant-mcp
+    - icon: fontawesome/brands/docker
+      link: https://hub.docker.com/r/jangoblockchained/homeassistant-mcp
+  analytics:
+    provider: google
+    property: !ENV GOOGLE_ANALYTICS_KEY
+
+extra_css:
+  - assets/stylesheets/extra.css
+
+copyright: Copyright © 2024 Jango Blockchained