atlas/home-voice-agent/TESTING.md

# Testing Guide

This guide covers how to test all components of the Atlas voice agent system.

## Prerequisites

1. **Install dependencies**:
   ```bash
   cd mcp-server
   pip install -r requirements.txt
   ```

2. **Ensure Ollama is running** (for local testing):
   ```bash
   # Check if Ollama is running
   curl http://localhost:11434/api/tags
   
   # If not running, start it:
   ollama serve
   ```

3. **Configure environment**:
   ```bash
   # Make sure .env is set correctly
   cd /home/beast/Code/atlas/home-voice-agent
   cat .env | grep OLLAMA
   ```

## Quick Test Suite

### 1. Test MCP Server

```bash
cd /home/beast/Code/atlas/home-voice-agent/mcp-server

# Start the server (in one terminal)
./run.sh

# In another terminal, test the server
python3 test_mcp.py

# Or test all tools
./test_all_tools.sh
```

**Expected output**: Should show all 22 tools registered and working.

### 2. Test LLM Connection

```bash
cd /home/beast/Code/atlas/home-voice-agent/llm-servers/4080

# Test connection
python3 test_connection.py

# Or use the local test script
./test_local.sh
```

**Expected output**: 
- ✅ Server is reachable
- ✅ Chat test successful with model response

### 3. Test LLM Router

```bash
cd /home/beast/Code/atlas/home-voice-agent/routing

# Run router tests
python3 test_router.py
```

**Expected output**: All routing tests passing.

### 4. Test MCP Adapter

```bash
cd /home/beast/Code/atlas/home-voice-agent/mcp-adapter

# Test adapter (MCP server must be running)
python3 test_adapter.py
```

**Expected output**: Tool discovery and calling working.

### 5. Test Individual Components

```bash
# Test memory system
cd /home/beast/Code/atlas/home-voice-agent/memory
python3 test_memory.py

# Test monitoring
cd /home/beast/Code/atlas/home-voice-agent/monitoring
python3 test_monitoring.py

# Test safety boundaries
cd /home/beast/Code/atlas/home-voice-agent/safety/boundaries
python3 test_boundaries.py

# Test confirmations
cd /home/beast/Code/atlas/home-voice-agent/safety/confirmations
python3 test_confirmations.py

# Test conversation management
cd /home/beast/Code/atlas/home-voice-agent/conversation
python3 test_session.py

# Test summarization
cd /home/beast/Code/atlas/home-voice-agent/conversation/summarization
python3 test_summarization.py
```

## End-to-End Testing

### Test Full Flow: User Query → LLM → Tool Call → Response

1. **Start MCP Server**:
   ```bash
   cd /home/beast/Code/atlas/home-voice-agent/mcp-server
   ./run.sh
   ```

2. **Test with a simple query** (using curl or Python):

```python
import requests
import json

# Test query
mcp_url = "http://localhost:8000/mcp"
payload = {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
        "name": "get_current_time",
        "arguments": {}
    }
}

response = requests.post(mcp_url, json=payload)
print(json.dumps(response.json(), indent=2))
```

3. **Test LLM with tool calling**:

```python
from routing.router import LLMRouter
from mcp_adapter.adapter import MCPAdapter

# Initialize
router = LLMRouter()
adapter = MCPAdapter("http://localhost:8000/mcp")

# Route request
decision = router.route_request(agent_type="family")
print(f"Routing to: {decision.agent_type} at {decision.config.base_url}")

# Get tools
tools = adapter.discover_tools()
print(f"Available tools: {len(tools)}")

# Make LLM request with tools
# (This would require full LLM integration)
```

## Web Dashboard Testing

1. **Start MCP Server** (includes dashboard):
   ```bash
   cd /home/beast/Code/atlas/home-voice-agent/mcp-server
   ./run.sh
   ```

2. **Open in browser**:
   - Dashboard: http://localhost:8000
   - API Docs: http://localhost:8000/docs
   - Health: http://localhost:8000/health

3. **Test Dashboard Endpoints**:
   ```bash
   # Status
   curl http://localhost:8000/api/dashboard/status
   
   # Conversations
   curl http://localhost:8000/api/dashboard/conversations
   
   # Tasks
   curl http://localhost:8000/api/dashboard/tasks
   
   # Timers
   curl http://localhost:8000/api/dashboard/timers
   
   # Logs
   curl http://localhost:8000/api/dashboard/logs
   ```

4. **Test Admin Panel**:
   - Open http://localhost:8000
   - Click "Admin Panel" tab
   - Test log browser, kill switches, access control

## Manual Tool Testing

### Test Individual Tools

```bash
cd /home/beast/Code/atlas/home-voice-agent/mcp-server

# Test echo tool
curl -X POST http://localhost:8000/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
      "name": "echo",
      "arguments": {"message": "Hello, Atlas!"}
    }
  }'

# Test time tool
curl -X POST http://localhost:8000/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tools/call",
    "params": {
      "name": "get_current_time",
      "arguments": {}
    }
  }'

# Test weather tool (requires API key)
curl -X POST http://localhost:8000/mcp \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 3,
    "method": "tools/call",
    "params": {
      "name": "weather",
      "arguments": {"location": "New York"}
    }
  }'
```

## Integration Testing

### Test Memory System with MCP Tools

```bash
cd /home/beast/Code/atlas/home-voice-agent/memory
python3 integration_test.py
```

### Test Full Conversation Flow

1. Create a test script that:
   - Creates a session
   - Sends a user message
   - Routes to LLM
   - Calls tools if needed
   - Gets response
   - Stores in session

## Troubleshooting

### MCP Server Not Starting

```bash
# Check if port 8000 is in use
lsof -i:8000

# Kill existing process
pkill -f "uvicorn|mcp_server"

# Restart
cd mcp-server
./run.sh
```

### Ollama Connection Failed

```bash
# Check Ollama is running
curl http://localhost:11434/api/tags

# Check .env configuration
cat .env | grep OLLAMA

# Test connection
cd llm-servers/4080
python3 test_connection.py
```

### Tools Not Working

```bash
# Check tool registry
cd mcp-server
python3 -c "from tools.registry import ToolRegistry; r = ToolRegistry(); print(f'Tools: {len(r.list_tools())}')"

# Test specific tool
python3 -c "from tools.registry import ToolRegistry; r = ToolRegistry(); print(r.call_tool('echo', {'message': 'test'}))"
```

## Test Checklist

- [ ] MCP server starts and shows 22 tools
- [ ] LLM connection works (local or remote)
- [ ] Router correctly routes requests
- [ ] MCP adapter discovers tools
- [ ] Individual tools work (echo, time, weather, etc.)
- [ ] Memory tools work (store, get, search)
- [ ] Dashboard loads and shows data
- [ ] Admin panel functions work
- [ ] Logs are being written
- [ ] All unit tests pass

## Running All Tests

```bash
# Run all test scripts
cd /home/beast/Code/atlas/home-voice-agent

# MCP Server
cd mcp-server && python3 test_mcp.py && cd ..

# LLM Connection
cd llm-servers/4080 && python3 test_connection.py && cd ../..

# Router
cd routing && python3 test_router.py && cd ..

# Memory
cd memory && python3 test_memory.py && cd ..

# Monitoring
cd monitoring && python3 test_monitoring.py && cd ..

# Safety
cd safety/boundaries && python3 test_boundaries.py && cd ../..
cd safety/confirmations && python3 test_confirmations.py && cd ../..
```

## Next Steps

After basic tests pass:
1. Test end-to-end conversation flow
2. Test tool calling from LLM
3. Test memory integration
4. Test safety boundaries
5. Test confirmation flows
6. Performance testing