From cb62057b16dceeaec465b4ad768c0bf195b4f1d6 Mon Sep 17 00:00:00 2001 From: Scott Steele Date: Mon, 11 Aug 2025 18:03:54 -0400 Subject: [PATCH] feat: add frontend, backend, infra (EC2 pilot) + configs --- 1 | 3 - backend/AI_SETUP.md | 92 + backend/CHUNKING_README.md | 123 + backend/TEST_REPORT.md | 303 ++ backend/add_clean_hr_docs.py | 95 + backend/add_hr_docs.py | 80 + backend/app/api/__init__.py | 0 backend/app/api/chat.py | 79 + backend/app/api/documents.py | 80 + backend/app/core/__init__.py | 0 backend/app/main.py | 26 + backend/app/models/__init__.py | 0 backend/app/models/chat.py | 21 + backend/app/services/__init__.py | 0 backend/app/services/ai_service.py | 137 + backend/app/services/chunking_service.py | 227 + backend/app/services/embedding_service.py | 72 + backend/app/services/rag_service.py | 212 + backend/app/services/vector_service.py | 145 + backend/aws_auto_recovery.sh | 257 ++ backend/aws_ingest_documents.sh | 447 ++ backend/aws_manage_ip.sh | 145 + backend/aws_startup_check.sh | 179 + backend/aws_sync_deployment.sh | 291 ++ backend/backend/app/services/__init__.py | 0 backend/check_kb_size.py | 35 + backend/ingest_clean_documents.py | 367 ++ .../load_test_results_20250809_225610.json | 122 + backend/privategpt-ui@0.0.0 | 0 backend/quick_test.py | 44 + backend/rag_test_results.json | 209 + backend/reset_vector_db.py | 57 + backend/test_aws_chat.py | 149 + backend/test_chunking.py | 123 + backend/test_improvements.py | 73 + backend/test_ingest_large.py | 217 + backend/test_legal_documents.py | 400 ++ backend/test_rag_queries.py | 154 + backend/test_rag_questions.py | 270 ++ backend/tests/chaos_test.py | 367 ++ backend/tests/e2e_test.py | 446 ++ backend/tests/load_test.py | 269 ++ backend/tests/security_test.py | 350 ++ backend/verify_system.py | 43 + backend/vite | 0 frontend/.gitignore | 24 + frontend/AWS_DEPLOYMENT_GUIDE.md | 309 ++ frontend/AWS_QUICK_REFERENCE.md | 218 + frontend/App.jsx | 183 + frontend/App.jsx.backup | 183 + frontend/DEPLOYMENT_STATUS.md | 125 + frontend/DEPLOY_NOW.md | 208 + frontend/README.md | 12 + frontend/backend/AI_SETUP.md | 92 + frontend/backend/CHUNKING_README.md | 123 + frontend/backend/TEST_REPORT.md | 303 ++ frontend/backend/add_clean_hr_docs.py | 95 + frontend/backend/add_hr_docs.py | 80 + frontend/backend/app/api/__init__.py | 0 frontend/backend/app/api/chat.py | 79 + frontend/backend/app/api/documents.py | 80 + frontend/backend/app/core/__init__.py | 0 frontend/backend/app/main.py | 26 + frontend/backend/app/models/__init__.py | 0 frontend/backend/app/models/chat.py | 21 + frontend/backend/app/services/__init__.py | 0 frontend/backend/app/services/ai_service.py | 137 + .../backend/app/services/chunking_service.py | 227 + .../backend/app/services/embedding_service.py | 72 + frontend/backend/app/services/rag_service.py | 212 + .../backend/app/services/vector_service.py | 145 + frontend/backend/aws_auto_recovery.sh | 257 ++ frontend/backend/aws_ingest_documents.sh | 447 ++ frontend/backend/aws_manage_ip.sh | 145 + frontend/backend/aws_startup_check.sh | 179 + frontend/backend/aws_sync_deployment.sh | 291 ++ .../backend/backend/app/services/__init__.py | 0 frontend/backend/check_kb_size.py | 35 + frontend/backend/ingest_clean_documents.py | 367 ++ .../load_test_results_20250809_225610.json | 122 + frontend/backend/privategpt-ui@0.0.0 | 0 frontend/backend/quick_test.py | 44 + frontend/backend/rag_test_results.json | 209 + frontend/backend/reset_vector_db.py | 57 + frontend/backend/test_aws_chat.py | 149 + frontend/backend/test_chunking.py | 123 + frontend/backend/test_improvements.py | 73 + frontend/backend/test_ingest_large.py | 217 + frontend/backend/test_legal_documents.py | 400 ++ frontend/backend/test_rag_queries.py | 154 + frontend/backend/test_rag_questions.py | 270 ++ frontend/backend/tests/chaos_test.py | 367 ++ frontend/backend/tests/e2e_test.py | 446 ++ frontend/backend/tests/load_test.py | 269 ++ frontend/backend/tests/security_test.py | 350 ++ frontend/backend/verify_system.py | 43 + frontend/backend/vite | 0 frontend/complete_aws_deployment.sh | 307 ++ frontend/comprehensive_tests.sh | 323 ++ frontend/critical_fixes_for_monday.sh | 662 +++ frontend/deploy_conversation_fix.sh | 39 + frontend/deploy_to_aws.sh | 240 + frontend/deployment_audit.md | 61 + frontend/dist.tgz | Bin 0 -> 71592 bytes frontend/ec2-amazon-linux-setup.sh | 140 + frontend/ec2-credentials.txt | 13 + frontend/ec2-setup.sh | 228 + frontend/eslint.config.js | 29 + frontend/index.html | 14 + frontend/monday_demo_script.sh | 168 + frontend/nginx-ssl.conf | 37 + frontend/package-lock.json | 4110 +++++++++++++++++ frontend/package.json | 32 + frontend/postcss.config.js | 11 + frontend/public/assets/tailwind.css | 107 + frontend/public/vite.svg | 1 + frontend/quick_test.sh | 105 + frontend/src/App.css | 42 + frontend/src/App.jsx | 289 ++ frontend/src/App.jsx.08102025 | 285 ++ frontend/src/App.jsx.backup | 281 ++ frontend/src/SimpleApp.jsx | 127 + frontend/src/assets/react.svg | 1 + frontend/src/components/ChatInterface.jsx | 52 + frontend/src/components/MessageBubble.jsx | 18 + frontend/src/index.css | 130 + frontend/src/main.jsx | 10 + frontend/src/ui-20250810-2147.tgz | 0 frontend/tailwind.config.js | 14 + frontend/test-api.html | 51 + frontend/test_connection.py | 49 + frontend/ui-20250810-2147.tgz | Bin 0 -> 71748 bytes frontend/ui-20250810-2155.tgz | Bin 0 -> 71739 bytes frontend/vite.config.js | 18 + 134 files changed, 22668 insertions(+), 3 deletions(-) delete mode 100644 1 create mode 100644 backend/AI_SETUP.md create mode 100644 backend/CHUNKING_README.md create mode 100644 backend/TEST_REPORT.md create mode 100644 backend/add_clean_hr_docs.py create mode 100644 backend/add_hr_docs.py create mode 100644 backend/app/api/__init__.py create mode 100644 backend/app/api/chat.py create mode 100644 backend/app/api/documents.py create mode 100644 backend/app/core/__init__.py create mode 100644 backend/app/main.py create mode 100644 backend/app/models/__init__.py create mode 100644 backend/app/models/chat.py create mode 100644 backend/app/services/__init__.py create mode 100644 backend/app/services/ai_service.py create mode 100644 backend/app/services/chunking_service.py create mode 100644 backend/app/services/embedding_service.py create mode 100644 backend/app/services/rag_service.py create mode 100644 backend/app/services/vector_service.py create mode 100755 backend/aws_auto_recovery.sh create mode 100755 backend/aws_ingest_documents.sh create mode 100755 backend/aws_manage_ip.sh create mode 100755 backend/aws_startup_check.sh create mode 100755 backend/aws_sync_deployment.sh create mode 100644 backend/backend/app/services/__init__.py create mode 100644 backend/check_kb_size.py create mode 100644 backend/ingest_clean_documents.py create mode 100644 backend/load_test_results_20250809_225610.json create mode 100644 backend/privategpt-ui@0.0.0 create mode 100644 backend/quick_test.py create mode 100644 backend/rag_test_results.json create mode 100644 backend/reset_vector_db.py create mode 100644 backend/test_aws_chat.py create mode 100644 backend/test_chunking.py create mode 100644 backend/test_improvements.py create mode 100644 backend/test_ingest_large.py create mode 100644 backend/test_legal_documents.py create mode 100644 backend/test_rag_queries.py create mode 100644 backend/test_rag_questions.py create mode 100755 backend/tests/chaos_test.py create mode 100755 backend/tests/e2e_test.py create mode 100755 backend/tests/load_test.py create mode 100755 backend/tests/security_test.py create mode 100644 backend/verify_system.py create mode 100644 backend/vite create mode 100644 frontend/.gitignore create mode 100644 frontend/AWS_DEPLOYMENT_GUIDE.md create mode 100644 frontend/AWS_QUICK_REFERENCE.md create mode 100644 frontend/App.jsx create mode 100644 frontend/App.jsx.backup create mode 100644 frontend/DEPLOYMENT_STATUS.md create mode 100644 frontend/DEPLOY_NOW.md create mode 100644 frontend/README.md create mode 100644 frontend/backend/AI_SETUP.md create mode 100644 frontend/backend/CHUNKING_README.md create mode 100644 frontend/backend/TEST_REPORT.md create mode 100644 frontend/backend/add_clean_hr_docs.py create mode 100644 frontend/backend/add_hr_docs.py create mode 100644 frontend/backend/app/api/__init__.py create mode 100644 frontend/backend/app/api/chat.py create mode 100644 frontend/backend/app/api/documents.py create mode 100644 frontend/backend/app/core/__init__.py create mode 100644 frontend/backend/app/main.py create mode 100644 frontend/backend/app/models/__init__.py create mode 100644 frontend/backend/app/models/chat.py create mode 100644 frontend/backend/app/services/__init__.py create mode 100644 frontend/backend/app/services/ai_service.py create mode 100644 frontend/backend/app/services/chunking_service.py create mode 100644 frontend/backend/app/services/embedding_service.py create mode 100644 frontend/backend/app/services/rag_service.py create mode 100644 frontend/backend/app/services/vector_service.py create mode 100755 frontend/backend/aws_auto_recovery.sh create mode 100755 frontend/backend/aws_ingest_documents.sh create mode 100755 frontend/backend/aws_manage_ip.sh create mode 100755 frontend/backend/aws_startup_check.sh create mode 100755 frontend/backend/aws_sync_deployment.sh create mode 100644 frontend/backend/backend/app/services/__init__.py create mode 100644 frontend/backend/check_kb_size.py create mode 100644 frontend/backend/ingest_clean_documents.py create mode 100644 frontend/backend/load_test_results_20250809_225610.json create mode 100644 frontend/backend/privategpt-ui@0.0.0 create mode 100644 frontend/backend/quick_test.py create mode 100644 frontend/backend/rag_test_results.json create mode 100644 frontend/backend/reset_vector_db.py create mode 100644 frontend/backend/test_aws_chat.py create mode 100644 frontend/backend/test_chunking.py create mode 100644 frontend/backend/test_improvements.py create mode 100644 frontend/backend/test_ingest_large.py create mode 100644 frontend/backend/test_legal_documents.py create mode 100644 frontend/backend/test_rag_queries.py create mode 100644 frontend/backend/test_rag_questions.py create mode 100755 frontend/backend/tests/chaos_test.py create mode 100755 frontend/backend/tests/e2e_test.py create mode 100755 frontend/backend/tests/load_test.py create mode 100755 frontend/backend/tests/security_test.py create mode 100644 frontend/backend/verify_system.py create mode 100644 frontend/backend/vite create mode 100755 frontend/complete_aws_deployment.sh create mode 100755 frontend/comprehensive_tests.sh create mode 100755 frontend/critical_fixes_for_monday.sh create mode 100755 frontend/deploy_conversation_fix.sh create mode 100755 frontend/deploy_to_aws.sh create mode 100644 frontend/deployment_audit.md create mode 100644 frontend/dist.tgz create mode 100755 frontend/ec2-amazon-linux-setup.sh create mode 100644 frontend/ec2-credentials.txt create mode 100755 frontend/ec2-setup.sh create mode 100644 frontend/eslint.config.js create mode 100644 frontend/index.html create mode 100755 frontend/monday_demo_script.sh create mode 100644 frontend/nginx-ssl.conf create mode 100644 frontend/package-lock.json create mode 100644 frontend/package.json create mode 100644 frontend/postcss.config.js create mode 100644 frontend/public/assets/tailwind.css create mode 100644 frontend/public/vite.svg create mode 100755 frontend/quick_test.sh create mode 100644 frontend/src/App.css create mode 100644 frontend/src/App.jsx create mode 100644 frontend/src/App.jsx.08102025 create mode 100644 frontend/src/App.jsx.backup create mode 100644 frontend/src/SimpleApp.jsx create mode 100644 frontend/src/assets/react.svg create mode 100644 frontend/src/components/ChatInterface.jsx create mode 100644 frontend/src/components/MessageBubble.jsx create mode 100644 frontend/src/index.css create mode 100644 frontend/src/main.jsx create mode 100644 frontend/src/ui-20250810-2147.tgz create mode 100644 frontend/tailwind.config.js create mode 100644 frontend/test-api.html create mode 100644 frontend/test_connection.py create mode 100644 frontend/ui-20250810-2147.tgz create mode 100644 frontend/ui-20250810-2155.tgz create mode 100644 frontend/vite.config.js diff --git a/1 b/1 deleted file mode 100644 index d0ee3b1..0000000 --- a/1 +++ /dev/null @@ -1,3 +0,0 @@ -venv/ -__pycache__/ -*.pyc diff --git a/backend/AI_SETUP.md b/backend/AI_SETUP.md new file mode 100644 index 0000000..9ea48d8 --- /dev/null +++ b/backend/AI_SETUP.md @@ -0,0 +1,92 @@ +# AI Integration Setup + +## Overview + +Your PrivateGPT backend now includes AI integration capabilities using OpenAI's API. The system can operate in two modes: + +1. **Test Mode** (Current): Uses predefined responses for testing +2. **Production Mode**: Uses OpenAI API for real AI responses + +## Current Status: Test Mode + +The system is currently running in **Test Mode** with intelligent fallback responses. This allows you to test the chat functionality without requiring an OpenAI API key. + +## Setting Up OpenAI API (Production Mode) + +To enable real AI responses, follow these steps: + +### 1. Get OpenAI API Key + +1. Go to [OpenAI's website](https://platform.openai.com/) +2. Sign up or log in to your account +3. Navigate to the API keys section +4. Create a new API key +5. Copy the key (it starts with `sk-`) + +### 2. Update Environment Variables + +Edit the `.env` file in the backend directory: + +```bash +# Replace this line: +OPENAI_API_KEY=sk-placeholder-replace-with-your-real-api-key + +# With your actual API key: +OPENAI_API_KEY=sk-your-actual-api-key-here +``` + +### 3. Configure AI Settings (Optional) + +You can customize the AI behavior by modifying these settings in `.env`: + +```bash +OPENAI_MODEL=gpt-4o-mini # AI model to use +OPENAI_MAX_TOKENS=1000 # Maximum response length +OPENAI_TEMPERATURE=0.7 # Response creativity (0-1) +``` + +### 4. Restart Backend Server + +After updating the API key, restart your backend server: + +```bash +# Stop the current server (Ctrl+C) and restart: +cd backend +source venv/bin/activate +uvicorn app.main:app --reload --host 127.0.0.1 --port 8000 +``` + +## Legal Professional Features + +The AI integration includes: + +- **Legal-focused prompts**: Responses tailored for legal professionals +- **Professional disclaimers**: Always reminds users that AI supplements, not replaces, professional judgment +- **Contextual responses**: Understands legal terminology and concepts +- **Privacy considerations**: Built with confidentiality in mind + +## Cost Considerations + +- OpenAI API usage is pay-per-token +- Current settings limit responses to 1000 tokens to control costs +- Monitor your usage at [OpenAI's usage dashboard](https://platform.openai.com/usage) + +## Testing + +Test your AI integration with these sample queries: + +1. "What is a legal contract?" +2. "Hello, I need help with compliance" +3. "What can you help me with?" + +## Troubleshooting + +- **"Technical difficulties" message**: Check your API key and internet connection +- **Test mode responses**: Ensure your API key doesn't start with `sk-placeholder` +- **Server errors**: Check the console logs for detailed error messages + +## Security Notes + +- Never commit your actual API key to version control +- Keep the `.env` file secure and private +- Consider using environment variables in production deployments diff --git a/backend/CHUNKING_README.md b/backend/CHUNKING_README.md new file mode 100644 index 0000000..0a00d3f --- /dev/null +++ b/backend/CHUNKING_README.md @@ -0,0 +1,123 @@ +# Document Chunking Implementation + +## āœ… Completed Features + +### 1. Intelligent Document Chunking Service +- **File**: `app/services/chunking_service.py` +- **Features**: + - Configurable chunk size (default: 800 characters) + - Overlap between chunks (default: 200 characters) for context preservation + - Sentence boundary preservation + - Automatic handling of small and large documents + - Metadata preservation and enrichment for each chunk + +### 2. Enhanced RAG Service Integration +- **File**: `app/services/rag_service.py` +- **Changes**: + - Integrated chunking service into document ingestion pipeline + - Enhanced metadata with chunk information (index, total chunks, character positions) + - Improved context retrieval with chunk-aware search results + +### 3. API Updates +- **File**: `app/api/documents.py` +- **Changes**: + - Updated ingestion response to include chunk count + - System status now reports chunking configuration + +## Configuration + +The chunking behavior can be configured via environment variables: + +```env +# Chunking Configuration +CHUNK_SIZE=800 # Target size for each chunk in characters +CHUNK_OVERLAP=200 # Overlap between consecutive chunks +MAX_CHUNK_SIZE=1000 # Maximum allowed chunk size +MIN_CHUNK_SIZE=100 # Minimum chunk size to create +``` + +## How It Works + +### Document Processing Flow +1. **Document Received**: API receives document with optional metadata +2. **Chunking**: Document is split into overlapping chunks + - Preserves sentence boundaries when possible + - Maintains context with overlap between chunks + - Each chunk inherits original document metadata +3. **Embedding Generation**: Each chunk gets its own embedding +4. **Vector Storage**: Chunks stored in Pinecone with enriched metadata +5. **Retrieval**: Searches return relevant chunks with chunk information + +### Example Usage + +```python +# Ingesting a large document +import requests + +document = "Your large document text here..." +metadata = {"document_type": "policy", "author": "HR Department"} + +response = requests.post( + "http://localhost:8000/api/ingest", + json={ + "documents": [document], + "metadata": [metadata] + } +) + +# Response includes chunk information +# { +# "success": true, +# "document_count": 1, +# "chunk_count": 10, +# "message": "Successfully ingested 1 documents as 10 chunks", +# ... +# } +``` + +## Testing + +### Unit Testing +Run the chunking test to verify functionality: +```bash +python test_chunking.py +``` + +### Integration Testing +Test end-to-end document ingestion with chunking: +```bash +python test_ingest_large.py +``` + +## Benefits + +1. **Better Context Preservation**: Overlap ensures important information isn't lost at chunk boundaries +2. **Improved Retrieval**: More granular chunks mean better semantic search results +3. **Scalability**: Can handle documents of any size +4. **Flexibility**: Configurable chunk sizes for different use cases +5. **Metadata Tracking**: Each chunk maintains reference to source document + +## Performance Considerations + +- **Chunk Size**: Smaller chunks = better precision but more storage/embeddings +- **Overlap Size**: More overlap = better context but increased storage +- **Processing Time**: Chunking adds minimal overhead (< 100ms for most documents) + +## Example Results + +For a 6,005 character HR policy document: +- Original documents: 1 +- Chunks created: 10 +- Average chunk size: ~600-800 characters +- Overlap preserved: ~80-100 characters between chunks + +The system successfully maintains context about "Dan Pfeiffer" across multiple chunks, ensuring queries about him retrieve relevant information regardless of which chunk contains the primary reference. + +## Next Steps + +With chunking complete, the system is ready for: +1. āœ… Handling large enterprise documents +2. āœ… Maintaining context across document sections +3. āœ… Improving search relevance with granular chunks +4. šŸ”„ API key authentication (next implementation) +5. šŸ”„ Production deployment configuration diff --git a/backend/TEST_REPORT.md b/backend/TEST_REPORT.md new file mode 100644 index 0000000..67070c7 --- /dev/null +++ b/backend/TEST_REPORT.md @@ -0,0 +1,303 @@ +# Private GPT System - Comprehensive Test Report + +**Test Date:** August 9, 2025 +**System URL:** https://44.202.131.48 +**Environment:** AWS EC2 t2.micro Instance + +--- + +## Executive Summary + +The Private GPT system underwent comprehensive testing across four major categories: End-to-End functionality, Load Performance, Security, and Chaos Engineering. While the system demonstrates basic functionality and some security strengths, significant improvements are needed before pilot deployment. + +### Overall System Health: āš ļø **NEEDS IMPROVEMENT** + +- **Overall Score:** 42% (E2E Testing) +- **Resilience Score:** 46% (Chaos Engineering) +- **Security Status:** Partially Secure +- **Performance Grade:** Acceptable (with concerns) + +--- + +## 1. End-to-End Testing Results + +### Test Coverage +- āœ… System responds to queries +- āœ… Knowledge base integration functional +- āœ… Basic session management works +- āŒ User journey completion failed +- āŒ Conversation memory not functioning +- āŒ Context retention issues + +### Key Metrics +| Metric | Result | Status | +|--------|--------|---------| +| Journey Success Rate | 0% | āŒ Critical | +| Memory Retention | 0% | āŒ Critical | +| Error Recovery | 67% | āš ļø Warning | +| Session Isolation | 0% | āŒ Critical | +| Response Consistency | 100% | āœ… Good | + +### Performance Breakdown +- **Average Response Time:** 11.87s +- **Fastest Response:** 0.89s +- **Slowest Response:** 22.59s +- **Performance Rating:** āš ļø ACCEPTABLE + +### Critical Issues +1. **Knowledge base queries failing** - System not retrieving document content +2. **Session context not maintained** between messages +3. **Slow response times** affecting user experience + +--- + +## 2. Load Testing Results + +### Test Parameters +- **Concurrent Users:** 5 +- **Requests per User:** 3 +- **Total Requests:** 15 + +### Performance Metrics +| Metric | Value | Status | +|--------|-------|---------| +| Success Rate | 100% | āœ… Excellent | +| Mean Response Time | 8.71s | āš ļø High | +| Median Response Time | 6.32s | āš ļø High | +| 90th Percentile | 20.42s | āŒ Critical | +| 95th Percentile | 21.02s | āŒ Critical | +| Throughput | 0.33 req/s | āŒ Low | + +### Load Test Analysis +- System handles 5 concurrent users without failures +- Response times significantly degrade under load +- Throughput below acceptable levels for production + +--- + +## 3. Security Testing Results + +### Security Assessment +| Category | Status | Risk Level | +|----------|--------|------------| +| Injection Protection | āœ… Safe | Low | +| Rate Limiting | āŒ Not Implemented | High | +| Session Management | āš ļø Weak | Medium | +| Input Validation | āš ļø Partial | Medium | +| DoS Resistance | āœ… Good | Low | +| Information Disclosure | āš ļø Headers Exposed | Low | +| CORS Configuration | āœ… Secure | Low | + +### Vulnerabilities Identified +1. **No rate limiting** - System vulnerable to abuse +2. **Weak session validation** - Accepts any session ID +3. **Input validation gaps** - Empty/malformed inputs not properly handled +4. **Server header exposed** - Minor information disclosure + +### Security Recommendations +1. **URGENT:** Implement rate limiting (e.g., 10 requests/minute per IP) +2. **HIGH:** Add proper session validation and management +3. **MEDIUM:** Strengthen input validation for all endpoints +4. **LOW:** Remove server headers from responses + +--- + +## 4. Chaos Engineering Results + +### Resilience Testing +| Test Scenario | Success Rate | Status | +|---------------|--------------|---------| +| Random Network Delays | 100% | āœ… Excellent | +| Connection Drops | 47% | āŒ Poor | +| Traffic Bursts | 0% | āŒ Critical | +| Malformed Data | 50% | āš ļø Moderate | +| Resource Exhaustion | 4% | āŒ Critical | +| Intermittent Failures | 75% | āš ļø Good | + +### System Resilience Issues +1. **Cannot handle traffic bursts** - Complete failure under spike load +2. **Poor connection recovery** - Only 47% recovery rate +3. **Resource limits needed** - System exhausted with 100 sessions +4. **Input validation gaps** - 50% of malformed data accepted + +--- + +## 5. Critical Issues Summary + +### šŸšØ **BLOCKERS for Pilot Deployment** + +1. **Knowledge Base Retrieval Failure** + - E2E tests show 0% success for document queries + - RAG integration not working properly + - **Impact:** Core functionality broken + +2. **No Session Context Maintained** + - Conversation history not preserved + - Each message treated independently + - **Impact:** Poor user experience + +3. **Cannot Handle Concurrent Load** + - 0% success rate with 50 simultaneous requests + - System fails completely under burst traffic + - **Impact:** Will crash with multiple users + +4. **No Rate Limiting** + - Vulnerable to DoS attacks + - No protection against abuse + - **Impact:** Security risk + +--- + +## 6. Performance Analysis + +### Response Time Distribution +``` +< 5s: 33% āœ… +5-10s: 27% āš ļø +10-20s: 27% āŒ +> 20s: 13% āŒ +``` + +### Bottleneck Analysis +1. **AWS Bedrock API calls** - Primary latency source (10-20s) +2. **Embedding generation** - Secondary bottleneck (2-5s) +3. **Vector search** - Minimal impact (<1s) + +--- + +## 7. Recommendations by Priority + +### šŸ”“ **CRITICAL (Must Fix Before Pilot)** + +1. **Fix Knowledge Base Integration** + - Debug Pinecone retrieval + - Verify embedding dimensions match + - Test document ingestion pipeline + +2. **Implement Session Management** + - Store conversation history + - Maintain context between messages + - Add session timeout (30 minutes) + +3. **Add Rate Limiting** + - Implement per-IP rate limits + - Add request queuing + - Return 429 status when exceeded + +4. **Improve Load Handling** + - Add connection pooling + - Implement request queuing + - Add circuit breaker pattern + +### šŸŸ” **HIGH (Should Fix Soon)** + +1. **Optimize Response Times** + - Implement response caching + - Add async processing where possible + - Consider faster AI model for simple queries + +2. **Strengthen Input Validation** + - Reject empty messages + - Limit message length (e.g., 2000 chars) + - Sanitize special characters + +3. **Add Monitoring** + - Response time tracking + - Error rate monitoring + - Resource usage alerts + +### šŸŸ¢ **MEDIUM (Nice to Have)** + +1. **Improve Error Messages** + - User-friendly error responses + - Helpful suggestions for issues + - Contact information for support + +2. **Add Health Checks** + - Database connectivity check + - AI service availability + - Automatic recovery attempts + +--- + +## 8. Go/No-Go Recommendation + +### āŒ **NOT READY FOR PILOT** + +**Current State:** The system has critical functionality issues that prevent successful operation. The core RAG feature is not working, session management is broken, and the system cannot handle expected load. + +### Minimum Requirements for Pilot: +- [ ] Fix knowledge base retrieval (0% ā†’ 80%+) +- [ ] Implement session context (0% ā†’ 100%) +- [ ] Handle 10+ concurrent users +- [ ] Add basic rate limiting +- [ ] Achieve <10s average response time + +### Estimated Time to Pilot Ready: +- **With focused effort:** 2-3 days +- **Key tasks:** Debug RAG, fix sessions, add rate limiting +- **Testing required:** Full regression after fixes + +--- + +## 9. Test Artifacts + +### Files Generated +- `load_test_results_20250809_225610.json` - Detailed load test data +- `TEST_REPORT.md` - This comprehensive report + +### Test Scripts Available +- `tests/e2e_test.py` - End-to-end testing +- `tests/load_test.py` - Performance testing +- `tests/security_test.py` - Security assessment +- `tests/chaos_test.py` - Resilience testing + +--- + +## 10. Next Steps + +### Immediate Actions (Today) +1. **Debug RAG integration** - Check Pinecone queries and embedding matching +2. **Fix session management** - Ensure conversation history is stored +3. **Run quick validation** after each fix + +### Before Monday Demo +1. **Implement rate limiting** - Basic protection +2. **Add request queuing** - Handle burst traffic +3. **Optimize slow queries** - Cache frequent responses +4. **Run full test suite** - Verify all fixes + +### For Production Readiness +1. Add comprehensive monitoring +2. Implement user authentication +3. Set up automated backups +4. Create disaster recovery plan +5. Document API specifications + +--- + +## Appendix: Test Commands + +```bash +# Quick Validation +curl -X POST https://44.202.131.48/api/chat/ \ + -H "Content-Type: application/json" \ + -d '{"message": "What are billing rates?", "session_id": "test"}' \ + --insecure + +# Full Test Suite +python tests/e2e_test.py # Functionality +python tests/load_test.py # Performance +python tests/security_test.py # Security +python tests/chaos_test.py # Resilience + +# Monitor Logs +ssh -i ~/.ssh/your-key.pem ubuntu@44.202.131.48 +sudo journalctl -u privategpt -f +``` + +--- + +**Report Generated:** August 9, 2025 22:58 PST +**Test Engineer:** AI Assistant +**System Version:** Private GPT v1.0 (Pilot) diff --git a/backend/add_clean_hr_docs.py b/backend/add_clean_hr_docs.py new file mode 100644 index 0000000..c9b48fc --- /dev/null +++ b/backend/add_clean_hr_docs.py @@ -0,0 +1,95 @@ +#!/usr/bin/env python3 +"""Add clean HR policies to the knowledge base""" +import requests +import json + +API_URL = "http://3.87.201.201:8000/api" + +# Clean HR policy documents without Dan Pfeiffer references +HR_DOCUMENTS = [ + { + "title": "PTO Policy", + "content": """PTO (Paid Time Off) Policy + +All full-time employees are entitled to 20 days of PTO per year, accruing at 1.67 days per month. +PTO requests must be submitted at least two weeks in advance for periods of 5 or more consecutive days. +Shorter PTO requests require 48 hours advance notice. +All PTO requests must be approved by the HR Director. +Unused PTO may be carried over up to 5 days into the next year. +PTO payout upon termination is provided for accrued but unused days up to a maximum of 20 days.""" + }, + { + "title": "Remote Work Policy", + "content": """Remote Work Policy + +Our firm offers flexible remote work arrangements for eligible employees. +Full-time employees may work remotely up to 3 days per week after completing their 90-day probationary period. +Remote work schedules must be approved in advance by the HR Director. +Employees must maintain core hours of 10 AM to 3 PM in their local time zone. +Remote workers must have reliable internet connection and a quiet workspace. +The firm will provide necessary equipment including laptop and software licenses. +Remote work privileges may be revoked if performance standards are not met.""" + }, + { + "title": "Time Off Approval Process", + "content": """Time Off and Leave Approval Process + +All requests for time off, including PTO, sick leave, personal days, and extended leave must follow this process: +1. Submit request through the HR portal or email to hr@firm.com +2. Requests are reviewed by your direct supervisor +3. Final approval must be granted by the HR Director +4. The HR Director has sole authority to approve all time off requests +5. Emergency leave should be communicated as soon as possible to both your supervisor and HR +6. For questions about time off policies, contact the HR department at hr@firm.com""" + }, + { + "title": "Employee Benefits", + "content": """Employee Benefits Overview + +Our firm provides comprehensive benefits to all full-time employees: +- Health insurance: Medical, dental, and vision coverage +- 401(k) retirement plan with 4% company match +- Life insurance: 2x annual salary +- Short-term and long-term disability insurance +- Professional development: CLE credits and training reimbursement up to $5,000 annually +- Bar dues and professional memberships covered +- Parking or transit subsidy up to $250 per month +- Gym membership reimbursement up to $100 per month""" + } +] + +def ingest_documents(): + """Ingest HR documents into the knowledge base""" + print("Adding clean HR policies to knowledge base...") + + # Convert documents to simple strings for ingestion + documents = [doc["content"] for doc in HR_DOCUMENTS] + + payload = { + "documents": documents, + "metadata": [] # Empty list for metadata + } + + print(f"\nIngesting {len(documents)} HR policy documents...") + + try: + response = requests.post( + f"{API_URL}/ingest", + json=payload, + timeout=30 + ) + + if response.status_code == 200: + result = response.json() + print(f"āœ“ Success: {result.get('message', 'Documents ingested')}") + print(f" Chunks created: {result.get('chunks_created', 'Unknown')}") + else: + print(f"āœ— Error {response.status_code}: {response.text}") + + except Exception as e: + print(f"āœ— Exception: {e}") + + print("\nāœ“ Clean HR policies ingestion complete!") + +if __name__ == "__main__": + ingest_documents() diff --git a/backend/add_hr_docs.py b/backend/add_hr_docs.py new file mode 100644 index 0000000..91687ae --- /dev/null +++ b/backend/add_hr_docs.py @@ -0,0 +1,80 @@ +#!/usr/bin/env python3 +"""Add HR policies to the knowledge base""" +import requests +import json + +API_URL = "http://3.87.201.201:8000/api" + +# HR policy documents +HR_DOCUMENTS = [ + { + "title": "PTO Policy", + "content": """PTO (Paid Time Off) Policy + +All full-time employees are entitled to 20 days of PTO per year, accruing at 1.67 days per month. +PTO requests must be submitted at least two weeks in advance for periods of 5 or more consecutive days. +Shorter PTO requests require 48 hours advance notice. +All PTO requests must be approved by Dan Pfeiffer, the HR Director. +Unused PTO may be carried over up to 5 days into the next year. +PTO payout upon termination is provided for accrued but unused days up to a maximum of 20 days.""" + }, + { + "title": "Remote Work Policy", + "content": """Remote Work Policy + +Our firm offers flexible remote work arrangements for eligible employees. +Full-time employees may work remotely up to 3 days per week after completing their 90-day probationary period. +Remote work schedules must be approved in advance by Dan Pfeiffer, the HR Director. +Employees must maintain core hours of 10 AM to 3 PM in their local time zone. +Remote workers must have reliable internet connection and a quiet workspace. +The firm will provide necessary equipment including laptop and software licenses. +Remote work privileges may be revoked if performance standards are not met.""" + }, + { + "title": "Time Off Approval Process", + "content": """Time Off and Leave Approval Process + +All requests for time off, including PTO, sick leave, personal days, and extended leave must follow this process: +1. Submit request through the HR portal or email to hr@firm.com +2. Requests are reviewed by your direct supervisor +3. Final approval must be granted by Dan Pfeiffer, HR Director +4. Dan Pfeiffer has sole authority to approve all time off requests +5. Emergency leave should be communicated as soon as possible to both your supervisor and Dan Pfeiffer +6. For questions about time off policies, contact Dan Pfeiffer directly at dpfeiffer@firm.com""" + } +] + +def ingest_documents(): + """Ingest HR documents into the knowledge base""" + print("Adding HR policies to knowledge base...") + + for doc in HR_DOCUMENTS: + print(f"\nIngesting: {doc['title']}") + + payload = { + "title": doc["title"], + "content": doc["content"], + "metadata": {"category": "HR Policy", "approver": "Dan Pfeiffer"} + } + + try: + response = requests.post( + f"{API_URL}/ingest", + json=payload, + timeout=30 + ) + + if response.status_code == 200: + result = response.json() + print(f"āœ“ Success: {result.get('message', 'Document ingested')}") + print(f" Chunks: {result.get('chunks_created', 'Unknown')}") + else: + print(f"āœ— Error {response.status_code}: {response.text}") + + except Exception as e: + print(f"āœ— Exception: {e}") + + print("\nāœ“ HR policies ingestion complete!") + +if __name__ == "__main__": + ingest_documents() diff --git a/backend/app/api/__init__.py b/backend/app/api/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/backend/app/api/chat.py b/backend/app/api/chat.py new file mode 100644 index 0000000..f1e6ae7 --- /dev/null +++ b/backend/app/api/chat.py @@ -0,0 +1,79 @@ +from fastapi import APIRouter, HTTPException +from app.models.chat import ChatRequest, ChatResponse +from app.services.rag_service import rag_service +import datetime +from typing import Dict, List + +router = APIRouter() + +# Store conversation history in memory (for testing) +# In production, use Redis or database +conversation_history: Dict[str, List[Dict]] = {} + + +@router.post("/chat/", response_model=ChatResponse) +async def chat(request: ChatRequest): + """Process chat message and return RAG-enhanced AI response""" + try: + # Get or create conversation history for this session + # Using a default session ID for now - in production, use actual session management + session_id = "default_session" + + if session_id not in conversation_history: + conversation_history[session_id] = [] + + # Add user message to history + conversation_history[session_id].append({ + "role": "user", + "content": request.message + }) + + # Build context-aware message including recent history + context_message = request.message + if len(conversation_history[session_id]) > 1: + # Include last 2 exchanges (4 messages) for context + recent_history = conversation_history[session_id][-5:-1] # Exclude current message + if recent_history: + history_text = "\n".join([ + f"{msg['role'].capitalize()}: {msg['content']}" + for msg in recent_history + ]) + # Format context more naturally without explicit labels + context_message = f"""Previous conversation: +{history_text} + +User: {request.message}""" + + # Use RAG service with context-aware message + rag_result = await rag_service.query_with_rag(context_message) + + # Add AI response to history + conversation_history[session_id].append({ + "role": "assistant", + "content": rag_result["response"] + }) + + # Keep conversation history limited to last 10 exchanges + if len(conversation_history[session_id]) > 20: + conversation_history[session_id] = conversation_history[session_id][-20:] + + id = int(datetime.datetime.now().timestamp()) + response = ChatResponse( + id=id, + role="assistant", + content=rag_result["response"], + timestamp=datetime.datetime.now() + ) + return response + + except Exception as e: + print(f"Chat endpoint error: {e}") + # Fallback response + id = int(datetime.datetime.now().timestamp()) + response = ChatResponse( + id=id, + role="assistant", + content="I'm experiencing technical difficulties. Please try again later.", + timestamp=datetime.datetime.now() + ) + return response diff --git a/backend/app/api/documents.py b/backend/app/api/documents.py new file mode 100644 index 0000000..74a823f --- /dev/null +++ b/backend/app/api/documents.py @@ -0,0 +1,80 @@ +from fastapi import APIRouter, HTTPException +from pydantic import BaseModel +from typing import List, Dict, Any, Optional +from app.services.rag_service import rag_service +import datetime + +router = APIRouter() + +class DocumentIngestionRequest(BaseModel): + documents: List[str] + metadata: Optional[List[Dict[str, Any]]] = None + +class DocumentIngestionResponse(BaseModel): + success: bool + message: str + document_count: int + chunk_count: int + doc_ids: List[str] + timestamp: datetime.datetime + +class SystemStatusResponse(BaseModel): + status: str + vector_database: Dict[str, Any] + embedding_model: str + text_generation_model: str + configuration: Dict[str, Any] + timestamp: datetime.datetime + +@router.post("/ingest", response_model=DocumentIngestionResponse) +async def ingest_documents(request: DocumentIngestionRequest): + """Ingest documents into the RAG system""" + try: + result = await rag_service.ingest_documents( + documents=request.documents, + metadata=request.metadata + ) + + if result["success"]: + return DocumentIngestionResponse( + success=True, + message=result["message"], + document_count=result["document_count"], + chunk_count=result.get("chunk_count", result["document_count"]), + doc_ids=result["doc_ids"], + timestamp=datetime.datetime.now() + ) + else: + raise HTTPException( + status_code=500, + detail=f"Document ingestion failed: {result.get('error', 'Unknown error')}" + ) + + except Exception as e: + print(f"Document ingestion endpoint error: {e}") + raise HTTPException( + status_code=500, + detail=f"Failed to ingest documents: {str(e)}" + ) + +@router.get("/status", response_model=SystemStatusResponse) +async def get_system_status(): + """Get RAG system status and statistics""" + try: + status = await rag_service.get_system_status() + + return SystemStatusResponse( + status=status["status"], + vector_database=status.get("vector_database", {}), + embedding_model=status.get("embedding_model", "unknown"), + text_generation_model=status.get("text_generation_model", "unknown"), + configuration=status.get("configuration", {}), + timestamp=datetime.datetime.now() + ) + + except Exception as e: + print(f"System status endpoint error: {e}") + raise HTTPException( + status_code=500, + detail=f"Failed to get system status: {str(e)}" + ) diff --git a/backend/app/core/__init__.py b/backend/app/core/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/backend/app/main.py b/backend/app/main.py new file mode 100644 index 0000000..173c626 --- /dev/null +++ b/backend/app/main.py @@ -0,0 +1,26 @@ +from fastapi import FastAPI +from fastapi.middleware.cors import CORSMiddleware +from app.api import chat, documents + +app = FastAPI(title="PrivateGPT UI Backend", version="1.0.0") + +# Add CORS middleware +app.add_middleware( + CORSMiddleware, + allow_origins=["http://localhost:5173", "http://127.0.0.1:5173", "http://localhost:5174", "http://127.0.0.1:5174"], # React dev server + allow_credentials=True, + allow_methods=["*"], + allow_headers=["*"], +) + +# Include API routers +app.include_router(chat.router, prefix="/api") +app.include_router(documents.router, prefix="/api") + +@app.get("/") +async def root(): + return {"message": "Welcome to the PrivateGPT UI Backend!", "docs": "/docs"} + +@app.get("/health") +async def health_check(): + return {"status": "healthy"} diff --git a/backend/app/models/__init__.py b/backend/app/models/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/backend/app/models/chat.py b/backend/app/models/chat.py new file mode 100644 index 0000000..46cde88 --- /dev/null +++ b/backend/app/models/chat.py @@ -0,0 +1,21 @@ +from datetime import datetime +from typing import Optional +from pydantic import BaseModel + + +class ChatMessage(BaseModel): + id: Optional[int] = None + role: str # 'user' or 'assistant' + content: str + timestamp: Optional[datetime] = None + + +class ChatRequest(BaseModel): + message: str + + +class ChatResponse(BaseModel): + id: int + role: str + content: str + timestamp: datetime diff --git a/backend/app/services/__init__.py b/backend/app/services/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/backend/app/services/ai_service.py b/backend/app/services/ai_service.py new file mode 100644 index 0000000..e19aa64 --- /dev/null +++ b/backend/app/services/ai_service.py @@ -0,0 +1,137 @@ +import os +import asyncio +from typing import Optional +import boto3 +import json +from botocore.exceptions import ClientError +from dotenv import load_dotenv + +# Load environment variables +load_dotenv() + +class AIService: + def __init__(self): + self.region_name = os.getenv("AWS_REGION", "us-east-1") + self.aws_access_key_id = os.getenv("AWS_ACCESS_KEY_ID") + self.aws_secret_access_key = os.getenv("AWS_SECRET_ACCESS_KEY") + self.model_id = os.getenv("BEDROCK_MODEL_ID", "amazon.titan-text-express-v1") + + self.test_mode = not all([self.aws_access_key_id, self.aws_secret_access_key]) + + if not self.test_mode: + self.bedrock_client = boto3.client( + service_name='bedrock-runtime', + region_name=self.region_name, + aws_access_key_id=self.aws_access_key_id, + aws_secret_access_key=self.aws_secret_access_key + ) + else: + self.bedrock_client = None + + async def _generate_test_response(self, message: str) -> str: + """Generate test response when AWS credentials are not available""" + message_lower = message.lower() + if any(word in message_lower for word in ['hello', 'hi', 'hey']): + return "Hello! I'm a mock response from the AI service. Please configure your AWS credentials to get live responses." + else: + return f"This is a test response for your message: '{message}'." + + async def generate_response(self, message: str, system_prompt: Optional[str] = None) -> str: + """Generate AI response using AWS Bedrock or test mode""" + if self.test_mode: + return await self._generate_test_response(message) + + prompt = f"{system_prompt}\n\nUser: {message}\n\nAssistant:" + + body = json.dumps({ + "inputText": prompt, + "textGenerationConfig": { + "maxTokenCount": 512, + "stopSequences": [], # Titan doesn't support custom stop sequences in this format + "temperature": 0.5, + "topP": 0.9 + } + }) + + try: + response = await asyncio.to_thread( + self.bedrock_client.invoke_model, + modelId=self.model_id, + body=body, + accept='application/json', + contentType='application/json' + ) + + response_body = json.loads(response.get('body').read()) + + # Try different response formats for different models + text_response = "" + if 'results' in response_body: + text_response = response_body['results'][0]['outputText'] + elif 'outputText' in response_body: + text_response = response_body['outputText'] + elif 'content' in response_body: + text_response = response_body['content'][0]['text'] + else: + text_response = str(response_body) + + # Clean up response - remove duplicate patterns + text_response = text_response.strip() + + # Remove any trailing incomplete sentences after stop sequences + stop_sequences = [ + "\n\nUser:", "\n\nAssistant:", "\n\nQuestion:", "\n\nAnswer:", + "\n\nBot:", "\n\nClient:", "\n\nCurrent question:", "\nUser:", + "Based on the following information", "--- CONTEXT START ---", + "IMPORTANT:", "Answer (based ONLY on the context provided):" + ] + for stop_seq in stop_sequences: + if stop_seq in text_response: + text_response = text_response.split(stop_seq)[0] + + # Remove duplicate assistant responses and role prefixes + if "Assistant:" in text_response: + parts = text_response.split("Assistant:") + text_response = parts[-1].strip() # Take the last part after Assistant: + + # Remove any question echoing patterns + if text_response.startswith("Based on"): + # Find where the actual answer starts + answer_markers = ["\n\n", ". ", ":\n"] + for marker in answer_markers: + if marker in text_response: + parts = text_response.split(marker, 1) + if len(parts) > 1 and len(parts[1]) > 20: # Ensure we have a substantial answer + text_response = parts[1] + break + + # Clean up any remaining formatting artifacts + text_response = text_response.replace("Answer:", "").strip() + text_response = text_response.replace("Response:", "").strip() + + return text_response.strip() + + except ClientError as e: + print(f"Bedrock API Error: {e}") + return f"Error communicating with AWS Bedrock: {e.response['Error']['Message']}" + except Exception as e: + print(f"An unexpected error occurred: {e}") + return "An unexpected error occurred. Please check the server logs." + + async def generate_legal_response(self, message: str) -> str: + """ + Generate AI response with legal professional context + """ + system_prompt = """You are an AI assistant designed to help legal professionals. + You provide helpful, accurate, and professional responses while being mindful of: + - Legal terminology and concepts + - Professional communication standards + - Confidentiality and privacy considerations + - The importance of human oversight in legal matters + + Always remind users that AI assistance should supplement, not replace, professional legal judgment.""" + + return await self.generate_response(message, system_prompt) + +# Global instance +ai_service = AIService() diff --git a/backend/app/services/chunking_service.py b/backend/app/services/chunking_service.py new file mode 100644 index 0000000..717a547 --- /dev/null +++ b/backend/app/services/chunking_service.py @@ -0,0 +1,227 @@ +import os +from typing import List, Dict, Any, Tuple +import re + +class ChunkingService: + def __init__(self): + # Chunking configuration - smaller chunks for better precision + self.chunk_size = int(os.getenv("CHUNK_SIZE", "300")) # Smaller chunks for better precision + self.chunk_overlap = int(os.getenv("CHUNK_OVERLAP", "50")) # Smaller overlap + self.max_chunk_size = int(os.getenv("MAX_CHUNK_SIZE", "600")) # Maximum chunk size + self.min_chunk_size = int(os.getenv("MIN_CHUNK_SIZE", "100")) # Minimum chunk size + + # Sentence splitting pattern + self.sentence_endings = re.compile(r'[.!?]\s+') + + def chunk_text(self, text: str, metadata: Dict[str, Any] = None) -> List[Tuple[str, Dict[str, Any]]]: + """ + Split text into chunks with overlap, preserving sentence boundaries + + Args: + text: The text to chunk + metadata: Optional metadata to attach to each chunk + + Returns: + List of tuples containing (chunk_text, chunk_metadata) + """ + if not text or len(text.strip()) == 0: + return [] + + # Clean the text + text = text.strip() + + # If text is small enough, return as single chunk + if len(text) <= self.chunk_size: + chunk_metadata = self._create_chunk_metadata( + original_metadata=metadata, + chunk_index=0, + total_chunks=1, + char_start=0, + char_end=len(text) + ) + return [(text, chunk_metadata)] + + # Split into sentences + sentences = self._split_into_sentences(text) + + # Create chunks with overlap + chunks = self._create_chunks_with_overlap(sentences, text) + + # Add metadata to each chunk + chunks_with_metadata = [] + total_chunks = len(chunks) + + for idx, (chunk_text, char_start, char_end) in enumerate(chunks): + chunk_metadata = self._create_chunk_metadata( + original_metadata=metadata, + chunk_index=idx, + total_chunks=total_chunks, + char_start=char_start, + char_end=char_end + ) + chunks_with_metadata.append((chunk_text, chunk_metadata)) + + return chunks_with_metadata + + def chunk_documents(self, documents: List[str], metadata_list: List[Dict[str, Any]] = None) -> Tuple[List[str], List[Dict[str, Any]]]: + """ + Chunk multiple documents with overlap + + Args: + documents: List of documents to chunk + metadata_list: Optional list of metadata for each document + + Returns: + Tuple of (chunked_texts, chunked_metadata) + """ + if metadata_list is None: + metadata_list = [{}] * len(documents) + + all_chunks = [] + all_metadata = [] + + for doc_idx, (doc, metadata) in enumerate(zip(documents, metadata_list)): + # Add document index to metadata + doc_metadata = metadata.copy() if metadata else {} + doc_metadata['source_document_index'] = doc_idx + + # Chunk the document + chunks_with_metadata = self.chunk_text(doc, doc_metadata) + + # Collect chunks and metadata + for chunk_text, chunk_metadata in chunks_with_metadata: + all_chunks.append(chunk_text) + all_metadata.append(chunk_metadata) + + return all_chunks, all_metadata + + def _split_into_sentences(self, text: str) -> List[str]: + """Split text into sentences""" + # Use regex to split by sentence endings + sentences = [] + current_pos = 0 + + for match in self.sentence_endings.finditer(text): + end_pos = match.end() + sentence = text[current_pos:end_pos].strip() + if sentence: + sentences.append(sentence) + current_pos = end_pos + + # Add any remaining text + if current_pos < len(text): + remaining = text[current_pos:].strip() + if remaining: + sentences.append(remaining) + + # If no sentences found, split by paragraphs + if not sentences: + sentences = [p.strip() for p in text.split('\n\n') if p.strip()] + + # If still no splits, split by lines + if not sentences: + sentences = [l.strip() for l in text.split('\n') if l.strip()] + + # If still nothing, return the whole text + if not sentences: + sentences = [text] + + return sentences + + def _create_chunks_with_overlap(self, sentences: List[str], original_text: str) -> List[Tuple[str, int, int]]: + """ + Create chunks from sentences with overlap + + Returns: + List of tuples (chunk_text, char_start, char_end) + """ + chunks = [] + current_chunk = [] + current_chunk_size = 0 + + for i, sentence in enumerate(sentences): + sentence_size = len(sentence) + + # If adding this sentence would exceed chunk size + if current_chunk_size + sentence_size > self.chunk_size and current_chunk: + # Create chunk + chunk_text = ' '.join(current_chunk) + char_start = original_text.find(current_chunk[0]) + char_end = char_start + len(chunk_text) + chunks.append((chunk_text, char_start, char_end)) + + # Calculate overlap - keep last sentences that fit in overlap size + overlap_chunk = [] + overlap_size = 0 + + for sent in reversed(current_chunk): + sent_size = len(sent) + if overlap_size + sent_size <= self.chunk_overlap: + overlap_chunk.insert(0, sent) + overlap_size += sent_size + else: + break + + # Start new chunk with overlap + current_chunk = overlap_chunk + current_chunk_size = overlap_size + + # Add sentence to current chunk + current_chunk.append(sentence) + current_chunk_size += sentence_size + + # If chunk exceeds max size, force a split + if current_chunk_size > self.max_chunk_size: + chunk_text = ' '.join(current_chunk[:-1]) if len(current_chunk) > 1 else current_chunk[0] + char_start = original_text.find(current_chunk[0]) + char_end = char_start + len(chunk_text) + chunks.append((chunk_text, char_start, char_end)) + + # Start new chunk with the last sentence + current_chunk = [sentence] + current_chunk_size = sentence_size + + # Add final chunk + if current_chunk: + chunk_text = ' '.join(current_chunk) + char_start = original_text.find(current_chunk[0]) + char_end = char_start + len(chunk_text) + chunks.append((chunk_text, char_start, char_end)) + + return chunks + + def _create_chunk_metadata(self, original_metadata: Dict[str, Any], + chunk_index: int, total_chunks: int, + char_start: int, char_end: int) -> Dict[str, Any]: + """Create metadata for a chunk""" + chunk_metadata = original_metadata.copy() if original_metadata else {} + + # Add chunking information + chunk_metadata.update({ + 'chunk_index': chunk_index, + 'total_chunks': total_chunks, + 'char_start': char_start, + 'char_end': char_end, + 'chunk_id': f"chunk_{chunk_index}_of_{total_chunks}" + }) + + return chunk_metadata + + def estimate_chunks(self, text: str) -> int: + """Estimate the number of chunks for a given text""" + if not text: + return 0 + + text_length = len(text) + + if text_length <= self.chunk_size: + return 1 + + # Account for overlap + effective_chunk_size = self.chunk_size - self.chunk_overlap + estimated_chunks = (text_length - self.chunk_size) // effective_chunk_size + 1 + + return max(1, estimated_chunks) + +# Global instance +chunking_service = ChunkingService() diff --git a/backend/app/services/embedding_service.py b/backend/app/services/embedding_service.py new file mode 100644 index 0000000..4075021 --- /dev/null +++ b/backend/app/services/embedding_service.py @@ -0,0 +1,72 @@ +import os +import asyncio +import boto3 +import json +from typing import List, Optional +from botocore.exceptions import ClientError +from dotenv import load_dotenv + +load_dotenv() + +class EmbeddingService: + def __init__(self): + self.region_name = os.getenv("AWS_REGION", "us-east-1") + self.aws_access_key_id = os.getenv("AWS_ACCESS_KEY_ID") + self.aws_secret_access_key = os.getenv("AWS_SECRET_ACCESS_KEY") + self.embedding_model_id = os.getenv("BEDROCK_EMBEDDING_MODEL_ID", "amazon.titan-embed-text-v2") + + self.test_mode = not all([self.aws_access_key_id, self.aws_secret_access_key]) + + if not self.test_mode: + self.bedrock_client = boto3.client( + service_name='bedrock-runtime', + region_name=self.region_name, + aws_access_key_id=self.aws_access_key_id, + aws_secret_access_key=self.aws_secret_access_key + ) + else: + self.bedrock_client = None + + async def generate_embeddings(self, texts: List[str]) -> List[List[float]]: + """Generate embeddings for a list of texts using Titan Embeddings""" + if self.test_mode: + # Return mock embeddings for testing + return [[0.1] * 1024 for _ in texts] # Titan v2 uses 1024 dimensions + + embeddings = [] + + for text in texts: + try: + body = json.dumps({ + "inputText": text + }) + + response = await asyncio.to_thread( + self.bedrock_client.invoke_model, + modelId=self.embedding_model_id, + body=body, + accept='application/json', + contentType='application/json' + ) + + response_body = json.loads(response.get('body').read()) + embedding = response_body.get('embedding', []) + embeddings.append(embedding) + + except ClientError as e: + print(f"Bedrock Embedding Error: {e}") + # Return zero vector on error + embeddings.append([0.0] * 1024) + except Exception as e: + print(f"Embedding generation error: {e}") + embeddings.append([0.0] * 1024) + + return embeddings + + async def generate_single_embedding(self, text: str) -> List[float]: + """Generate embedding for a single text""" + embeddings = await self.generate_embeddings([text]) + return embeddings[0] if embeddings else [0.0] * 1024 + +# Global instance +embedding_service = EmbeddingService() diff --git a/backend/app/services/rag_service.py b/backend/app/services/rag_service.py new file mode 100644 index 0000000..a862ae1 --- /dev/null +++ b/backend/app/services/rag_service.py @@ -0,0 +1,212 @@ +import os +from typing import List, Dict, Any, Optional +from app.services.embedding_service import embedding_service +from app.services.vector_service import vector_service +from app.services.ai_service import ai_service +from app.services.chunking_service import chunking_service + +class RAGService: + def __init__(self): + self.embedding_service = embedding_service + self.vector_service = vector_service + self.ai_service = ai_service + + # RAG Configuration + self.max_context_length = int(os.getenv("RAG_MAX_CONTEXT_LENGTH", "4000")) + self.similarity_threshold = float(os.getenv("RAG_SIMILARITY_THRESHOLD", "0.3")) # Lowered for better recall + self.top_k_results = int(os.getenv("RAG_TOP_K", "7")) # Increased to get more context + + async def ingest_documents(self, documents: List[str], metadata: List[Dict[str, Any]] = None) -> Dict[str, Any]: + """Ingest documents into the RAG system with intelligent chunking""" + try: + # Chunk documents with overlap for better context preservation + chunked_texts, chunked_metadata = chunking_service.chunk_documents( + documents=documents, + metadata_list=metadata + ) + + # Log chunking information + original_count = len(documents) + chunk_count = len(chunked_texts) + print(f"Chunked {original_count} documents into {chunk_count} chunks") + + # Generate embeddings for chunks + embeddings = await self.embedding_service.generate_embeddings(chunked_texts) + + # Store chunks in vector database + doc_ids = await self.vector_service.store_documents( + texts=chunked_texts, + embeddings=embeddings, + metadata=chunked_metadata + ) + + return { + "success": True, + "document_count": original_count, + "chunk_count": chunk_count, + "doc_ids": doc_ids, + "message": f"Successfully ingested {original_count} documents as {chunk_count} chunks" + } + + except Exception as e: + print(f"Document ingestion error: {e}") + return { + "success": False, + "error": str(e), + "message": "Failed to ingest documents" + } + + async def query_with_rag(self, question: str, use_rag: bool = True) -> Dict[str, Any]: + """Query the RAG system with context retrieval""" + try: + context_documents = [] + context_info = {"used_rag": False, "sources": []} + + if use_rag: + # Generate embedding for the question + query_embedding = await self.embedding_service.generate_single_embedding(question) + + # Search for relevant documents + search_results = await self.vector_service.search_similar( + query_embedding=query_embedding, + top_k=self.top_k_results + ) + + # Filter by similarity threshold and extract context + print(f"\n[RAG Debug] Query: {question[:50]}...") + print(f"[RAG Debug] Found {len(search_results)} results") + + for doc_id, score, metadata in search_results: + text_preview = metadata.get("text", "")[:100] + print(f"[RAG Debug] Score: {score:.3f} - Text: {text_preview}...") + + if score >= self.similarity_threshold: + context_documents.append(metadata.get("text", "")) + context_info["sources"].append({ + "doc_id": doc_id, + "similarity": score, + "chunk_info": { + "chunk_id": metadata.get("chunk_id", "unknown"), + "chunk_index": metadata.get("chunk_index", 0), + "total_chunks": metadata.get("total_chunks", 1) + }, + "preview": metadata.get("text", "")[:100] + "..." + }) + + print(f"[RAG Debug] Using {len(context_documents)} documents above threshold {self.similarity_threshold}") + + context_info["used_rag"] = len(context_documents) > 0 + + # Build enhanced question with context directly embedded + enhanced_question = self._build_enhanced_question(context_documents, question) + + # Generate AI response with context + system_prompt = self._build_system_prompt() + ai_response = await self.ai_service.generate_response( + message=enhanced_question, + system_prompt=system_prompt + ) + + return { + "response": ai_response, + "context_info": context_info, + "question": question + } + + except Exception as e: + print(f"RAG query error: {e}") + return { + "response": f"I encountered an error processing your question: {str(e)}", + "context_info": {"used_rag": False, "sources": [], "error": str(e)}, + "question": question + } + + def _build_context(self, context_documents: List[str], question: str) -> str: + """Build context string from retrieved documents""" + if not context_documents: + return "" + + # Combine and truncate context to fit within limits + combined_context = "\n\n".join(context_documents) + + if len(combined_context) > self.max_context_length: + combined_context = combined_context[:self.max_context_length] + "..." + + return combined_context + + def _build_system_prompt(self) -> str: + """Build system prompt for the AI assistant""" + return """You are an AI assistant for a law firm's Private GPT system. + You provide helpful, accurate, and professional responses based ONLY on the firm's knowledge base. + + CRITICAL INSTRUCTIONS: + 1. Only provide information that is explicitly stated in the provided context + 2. If information is not in the context, say "I don't have that information in my knowledge base" + 3. NEVER make up or invent client names, case details, dates, or any other information + 4. NEVER generate fictional documents, contracts, or correspondence + 5. If asked about something not in the context, be honest about the limitation + 6. Be concise and professional in your responses + + Remember: It's better to admit you don't know than to provide incorrect information.""" + + def _build_enhanced_question(self, context_documents: List[str], question: str) -> str: + """Build an enhanced question with context embedded directly""" + if not context_documents: + return question + + # Combine context documents + context_text = self._build_context(context_documents, question) + + # Clean the question to remove any conversation formatting + clean_question = question + if "Previous conversation:" in clean_question: + # Extract just the actual current question + parts = clean_question.split("\n\nUser: ") + if len(parts) > 1: + clean_question = parts[-1].strip() + else: + # Try another pattern + parts = clean_question.split("\nUser: ") + if len(parts) > 1: + clean_question = parts[-1].strip() + + # Create enhanced prompt with context directly in the question + enhanced_prompt = f"""Context from knowledge base: +{context_text} + +Based on the context above, please answer this question: {clean_question} + +Provide a direct answer using only the information from the context. If the information is not available in the context, say so clearly.""" + + return enhanced_prompt + + async def get_system_status(self) -> Dict[str, Any]: + """Get RAG system status""" + try: + # Get vector database stats + vector_stats = await self.vector_service.get_index_stats() + + return { + "status": "operational", + "vector_database": vector_stats, + "embedding_model": self.embedding_service.embedding_model_id, + "text_generation_model": self.ai_service.model_id, + "configuration": { + "max_context_length": self.max_context_length, + "similarity_threshold": self.similarity_threshold, + "top_k_results": self.top_k_results, + "chunking": { + "chunk_size": chunking_service.chunk_size, + "chunk_overlap": chunking_service.chunk_overlap, + "max_chunk_size": chunking_service.max_chunk_size + } + } + } + except Exception as e: + return { + "status": "error", + "error": str(e) + } + +# Global instance +rag_service = RAGService() diff --git a/backend/app/services/vector_service.py b/backend/app/services/vector_service.py new file mode 100644 index 0000000..f2accf7 --- /dev/null +++ b/backend/app/services/vector_service.py @@ -0,0 +1,145 @@ +import os +import uuid +from typing import List, Dict, Any, Optional, Tuple +from pinecone import Pinecone, ServerlessSpec +from dotenv import load_dotenv + +load_dotenv() + +class VectorService: + def __init__(self): + self.api_key = os.getenv("PINECONE_API_KEY") + self.environment = os.getenv("PINECONE_ENVIRONMENT", "us-east-1") + self.index_name = os.getenv("PINECONE_INDEX_NAME", "privategpt-embeddings") + self.host = os.getenv("PINECONE_HOST") + + self.test_mode = not self.api_key + + if not self.test_mode: + self.pc = Pinecone(api_key=self.api_key) + self.index = None + self._connect_to_index() + else: + self.pc = None + self.index = None + + def _connect_to_index(self): + """Connect to existing Pinecone index""" + try: + # Check if index exists + existing_indexes = [index.name for index in self.pc.list_indexes()] + + if self.index_name in existing_indexes: + self.index = self.pc.Index(self.index_name) + print(f"Connected to existing Pinecone index: {self.index_name}") + else: + print(f"Index {self.index_name} not found. Available indexes: {existing_indexes}") + # Create index if it doesn't exist + self._create_index() + + except Exception as e: + print(f"Error connecting to Pinecone: {e}") + + def _create_index(self): + """Create a new Pinecone index""" + try: + self.pc.create_index( + name=self.index_name, + dimension=1024, # Titan v2 embedding dimensions + metric="cosine", + spec=ServerlessSpec( + cloud="aws", + region=self.environment + ) + ) + self.index = self.pc.Index(self.index_name) + print(f"Created new Pinecone index: {self.index_name}") + except Exception as e: + print(f"Error creating Pinecone index: {e}") + + async def store_documents(self, texts: List[str], embeddings: List[List[float]], + metadata: List[Dict[str, Any]] = None) -> List[str]: + """Store document embeddings in Pinecone""" + if self.test_mode or not self.index: + return [f"test-id-{i}" for i in range(len(texts))] + + try: + # Generate IDs for the documents + doc_ids = [str(uuid.uuid4()) for _ in range(len(texts))] + + # Prepare vectors for upsert + vectors = [] + for i, (doc_id, embedding, text) in enumerate(zip(doc_ids, embeddings, texts)): + vector_data = { + "id": doc_id, + "values": embedding, + "metadata": { + "text": text[:1000], # Truncate text for metadata + "document_type": "user_upload", + "timestamp": str(uuid.uuid1().time), + **(metadata[i] if metadata and i < len(metadata) else {}) + } + } + vectors.append(vector_data) + + # Upsert vectors to Pinecone + self.index.upsert(vectors=vectors) + print(f"Successfully stored {len(vectors)} documents in Pinecone") + return doc_ids + + except Exception as e: + print(f"Error storing documents in Pinecone: {e}") + return [] + + async def search_similar(self, query_embedding: List[float], + top_k: int = 5) -> List[Tuple[str, float, Dict[str, Any]]]: + """Search for similar documents in Pinecone""" + if self.test_mode or not self.index: + # Return mock results for testing + return [ + ("test-doc-1", 0.9, {"text": "This is a test document for RAG functionality."}), + ("test-doc-2", 0.8, {"text": "Another test document with relevant information."}) + ] + + try: + # Query Pinecone + response = self.index.query( + vector=query_embedding, + top_k=top_k, + include_metadata=True, + include_values=False + ) + + # Extract results + results = [] + for match in response.matches: + doc_id = match.id + score = match.score + metadata = match.metadata + results.append((doc_id, score, metadata)) + + print(f"Found {len(results)} similar documents") + return results + + except Exception as e: + print(f"Error searching Pinecone: {e}") + return [] + + async def get_index_stats(self) -> Dict[str, Any]: + """Get index statistics""" + if self.test_mode or not self.index: + return {"total_vectors": 0, "status": "test_mode"} + + try: + stats = self.index.describe_index_stats() + return { + "total_vectors": stats.total_vector_count, + "dimension": stats.dimension, + "index_fullness": stats.index_fullness + } + except Exception as e: + print(f"Error getting index stats: {e}") + return {"error": str(e)} + +# Global instance +vector_service = VectorService() diff --git a/backend/aws_auto_recovery.sh b/backend/aws_auto_recovery.sh new file mode 100755 index 0000000..685e60e --- /dev/null +++ b/backend/aws_auto_recovery.sh @@ -0,0 +1,257 @@ +#!/bin/bash + +# AWS EC2 Private GPT System Auto-Recovery Script +# This script automatically restarts services and fixes common issues + +set -e + +echo "===========================================" +echo "Private GPT System Auto-Recovery" +echo "===========================================" +echo "" + +# Get IP from parameter, stdin, or prompt +if [ -n "$1" ]; then + EC2_HOST="$1" +elif [ ! -t 0 ]; then + # Read from stdin if available + read EC2_HOST +else + # Prompt for EC2 IP address + echo "Enter your EC2 instance public IP address:" + echo "(You can find this in AWS Console under EC2 > Instances)" + read -p "IP Address: " EC2_HOST +fi + +# Validate IP address format +if [[ ! $EC2_HOST =~ ^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$ ]]; then + echo "Invalid IP address format: $EC2_HOST" + exit 1 +fi + +# Configuration +SSH_KEY="$HOME/.ssh/Scott-Key.pem" +SSH_USER="ec2-user" + +echo "" +echo "Using EC2 instance at: $EC2_HOST" + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' # No Color + +# Function to run remote command +run_remote() { + ssh -i "$SSH_KEY" "$SSH_USER@$EC2_HOST" "$1" +} + +# Function to run remote command silently +run_remote_silent() { + ssh -i "$SSH_KEY" "$SSH_USER@$EC2_HOST" "$1" > /dev/null 2>&1 +} + +echo -e "${BLUE}Step 1: Verifying EC2 instance is reachable...${NC}" +if ! ssh -i "$SSH_KEY" -o ConnectTimeout=5 "$SSH_USER@$EC2_HOST" "echo 'Connected'" > /dev/null 2>&1; then + echo -e "${RED}āœ— Cannot connect to EC2 instance${NC}" + echo "" + echo "Please ensure:" + echo "1. Instance is started in AWS Console" + echo "2. Instance public IP is: $EC2_HOST" + echo "3. Security group allows SSH (port 22) from your IP" + echo "" + echo "To start instance from AWS CLI:" + echo "aws ec2 start-instances --instance-ids " + exit 1 +fi +echo -e "${GREEN}āœ“ EC2 instance is reachable${NC}" + +echo "" +echo -e "${BLUE}Step 2: Checking and fixing backend service...${NC}" + +# Stop the backend service first +echo " Stopping backend service..." +run_remote_silent "sudo systemctl stop privategpt-backend" + +# Kill any orphaned uvicorn processes +echo " Cleaning up orphaned processes..." +run_remote_silent "sudo pkill -f uvicorn || true" +run_remote_silent "sudo pkill -f 'python.*main:app' || true" + +# Clear any stale pid files +run_remote_silent "sudo rm -f /var/run/privategpt-backend.pid" + +# Ensure environment file exists +echo " Verifying environment configuration..." +ENV_EXISTS=$(run_remote "test -f /home/ec2-user/privategpt-backend/.env && echo 'yes' || echo 'no'") +if [ "$ENV_EXISTS" = "no" ]; then + echo -e "${YELLOW} āš  Environment file missing, creating from backup...${NC}" + run_remote "cp /home/ec2-user/privategpt-backend/.env.backup /home/ec2-user/privategpt-backend/.env 2>/dev/null || echo 'No backup found'" +fi + +# Start the backend service +echo " Starting backend service..." +run_remote "sudo systemctl start privategpt-backend" +sleep 3 + +# Check if it started successfully +BACKEND_STATUS=$(run_remote "sudo systemctl is-active privategpt-backend 2>/dev/null || echo 'inactive'") +if [ "$BACKEND_STATUS" = "active" ]; then + echo -e "${GREEN}āœ“ Backend service started successfully${NC}" +else + echo -e "${RED}āœ— Backend service failed to start${NC}" + echo " Recent logs:" + run_remote "sudo journalctl -u privategpt-backend -n 20 --no-pager" +fi + +echo "" +echo -e "${BLUE}Step 3: Checking and fixing Nginx...${NC}" + +# Test nginx configuration +echo " Testing Nginx configuration..." +NGINX_TEST=$(run_remote "sudo nginx -t 2>&1 | grep -c 'syntax is ok' || echo '0'") +if [ "$NGINX_TEST" = "1" ]; then + echo -e "${GREEN} āœ“ Nginx configuration is valid${NC}" +else + echo -e "${RED} āœ— Nginx configuration has errors${NC}" + run_remote "sudo nginx -t" +fi + +# Restart nginx +echo " Restarting Nginx..." +run_remote "sudo systemctl restart nginx" + +NGINX_STATUS=$(run_remote "sudo systemctl is-active nginx 2>/dev/null || echo 'inactive'") +if [ "$NGINX_STATUS" = "active" ]; then + echo -e "${GREEN}āœ“ Nginx restarted successfully${NC}" +else + echo -e "${RED}āœ— Nginx failed to start${NC}" +fi + +echo "" +echo -e "${BLUE}Step 4: Verifying API endpoints...${NC}" + +# Wait for services to stabilize +sleep 2 + +# Test backend health endpoint directly +echo " Testing backend API directly..." +BACKEND_HEALTH=$(run_remote "curl -s -o /dev/null -w '%{http_code}' http://localhost:8000/api/health 2>/dev/null || echo '000'") +if [ "$BACKEND_HEALTH" = "200" ]; then + echo -e "${GREEN} āœ“ Backend API responding on port 8000${NC}" +else + echo -e "${RED} āœ— Backend API not responding (HTTP $BACKEND_HEALTH)${NC}" +fi + +# Test through nginx proxy +echo " Testing API through Nginx proxy..." +PROXY_HEALTH=$(curl -k -s -o /dev/null -w '%{http_code}' "https://$EC2_HOST/api/health" 2>/dev/null || echo '000') +if [ "$PROXY_HEALTH" = "200" ]; then + echo -e "${GREEN} āœ“ Nginx proxy working correctly${NC}" +else + echo -e "${RED} āœ— Nginx proxy not working (HTTP $PROXY_HEALTH)${NC}" +fi + +echo "" +echo -e "${BLUE}Step 5: Testing Pinecone vector database...${NC}" +VECTOR_COUNT=$(run_remote "cd /home/ec2-user/privategpt-backend && python3 -c ' +from app.services.vector_service import VectorService +import asyncio +try: + vs = VectorService() + stats = vs.index.describe_index_stats() + print(stats.total_vector_count) +except: + print(0) +' 2>/dev/null || echo '0'") + +if [ "$VECTOR_COUNT" -gt 0 ]; then + echo -e "${GREEN}āœ“ Pinecone connected with $VECTOR_COUNT vectors${NC}" +else + echo -e "${YELLOW}āš  Pinecone has no vectors or connection failed${NC}" + echo " You may need to re-ingest documents" +fi + +echo "" +echo -e "${BLUE}Step 6: Testing chat functionality...${NC}" +CHAT_RESPONSE=$(curl -k -s -X POST "https://$EC2_HOST/api/chat/" \ + -H "Content-Type: application/json" \ + -d '{"message":"Hello","session_id":"test-recovery"}' 2>/dev/null) + +if echo "$CHAT_RESPONSE" | grep -q "response"; then + echo -e "${GREEN}āœ“ Chat API is functional${NC}" +else + echo -e "${RED}āœ— Chat API not responding correctly${NC}" + echo " Response: $CHAT_RESPONSE" +fi + +echo "" +echo -e "${BLUE}Step 7: Clearing potential issues...${NC}" + +# Clear any stale session data +echo " Clearing stale sessions..." +run_remote_silent "sudo rm -rf /tmp/privategpt-sessions/*" + +# Ensure log directory exists with correct permissions +echo " Fixing log permissions..." +run_remote_silent "sudo mkdir -p /var/log/privategpt" +run_remote_silent "sudo chown ec2-user:ec2-user /var/log/privategpt" + +# Clear old logs if they're too large +LOG_SIZE=$(run_remote "du -sm /var/log/privategpt 2>/dev/null | cut -f1 || echo '0'") +if [ "$LOG_SIZE" -gt 100 ]; then + echo " Rotating large logs ($LOG_SIZE MB)..." + run_remote_silent "sudo logrotate -f /etc/logrotate.d/privategpt 2>/dev/null || true" +fi + +echo "" +echo "===========================================" +echo -e "${GREEN}Recovery Process Complete!${NC}" +echo "===========================================" +echo "" +echo "System Status:" +echo "--------------" + +# Final status check +BACKEND_FINAL=$(run_remote "sudo systemctl is-active privategpt-backend 2>/dev/null || echo 'inactive'") +NGINX_FINAL=$(run_remote "sudo systemctl is-active nginx 2>/dev/null || echo 'inactive'") +API_FINAL=$(curl -k -s -o /dev/null -w '%{http_code}' "https://$EC2_HOST/api/health" 2>/dev/null || echo '000') + +if [ "$BACKEND_FINAL" = "active" ]; then + echo -e "Backend Service: ${GREEN}Active${NC}" +else + echo -e "Backend Service: ${RED}$BACKEND_FINAL${NC}" +fi + +if [ "$NGINX_FINAL" = "active" ]; then + echo -e "Nginx Service: ${GREEN}Active${NC}" +else + echo -e "Nginx Service: ${RED}$NGINX_FINAL${NC}" +fi + +if [ "$API_FINAL" = "200" ]; then + echo -e "API Status: ${GREEN}Healthy${NC}" +else + echo -e "API Status: ${RED}Not responding (HTTP $API_FINAL)${NC}" +fi + +echo -e "Vector Database: ${GREEN}$VECTOR_COUNT vectors${NC}" + +echo "" +echo "Access your Private GPT at:" +echo -e "${BLUE}https://$EC2_HOST/${NC}" +echo "" +echo "Note: You'll need to accept the self-signed certificate warning" +echo "" + +if [ "$BACKEND_FINAL" != "active" ] || [ "$API_FINAL" != "200" ]; then + echo -e "${YELLOW}āš  Some issues remain. Check logs with:${NC}" + echo "ssh -i $SSH_KEY $SSH_USER@$EC2_HOST 'sudo journalctl -u privategpt-backend -f'" + echo "" +fi + +echo "For real-time monitoring:" +echo "ssh -i $SSH_KEY $SSH_USER@$EC2_HOST 'sudo tail -f /var/log/privategpt/app.log'" +echo "" diff --git a/backend/aws_ingest_documents.sh b/backend/aws_ingest_documents.sh new file mode 100755 index 0000000..a0a00ab --- /dev/null +++ b/backend/aws_ingest_documents.sh @@ -0,0 +1,447 @@ +#!/bin/bash + +# AWS EC2 Document Ingestion Script +# Purpose: Ingest the same documents as on MacBook to ensure identical knowledge base +# Author: Scott Steele System +# Date: December 2024 + +set -e + +# Color codes +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' + +# Get EC2 IP +if [ -z "$1" ]; then + echo -e "${YELLOW}Please enter your EC2 instance public IP address:${NC}" + read -r EC2_IP +else + EC2_IP=$1 +fi + +API_URL="https://$EC2_IP/api" + +echo -e "${BLUE}========================================${NC}" +echo -e "${BLUE}Document Ingestion for AWS EC2${NC}" +echo -e "${BLUE}========================================${NC}" + +# Test API connectivity +echo -e "${YELLOW}Testing API connectivity...${NC}" +if curl -k -s "${API_URL}/health" > /dev/null 2>&1; then + echo -e "${GREEN}āœ“ API is reachable${NC}" +else + echo -e "${RED}āœ— Cannot reach API at ${API_URL}/health${NC}" + echo -e "${YELLOW}Make sure the EC2 instance is running and accessible${NC}" + exit 1 +fi + +# Function to ingest a document +ingest_document() { + local title=$1 + local content=$2 + local metadata=$3 + + echo -e "${YELLOW}Ingesting: $title${NC}" + + response=$(curl -k -s -X POST "${API_URL}/ingest" \ + -H "Content-Type: application/json" \ + -d "{ + \"documents\": [\"$content\"], + \"metadata\": [$metadata] + }") + + if echo "$response" | grep -q "\"success\":true"; then + echo -e "${GREEN}āœ“ Successfully ingested: $title${NC}" + else + echo -e "${RED}āœ— Failed to ingest: $title${NC}" + echo "Response: $response" + fi +} + +# Document 1: Client Engagement Letter +echo -e "${BLUE}Ingesting Client Engagement Letter Template...${NC}" +engagement_letter='SMITH, JOHNSON & ASSOCIATES LLP +ATTORNEY-CLIENT ENGAGEMENT AGREEMENT + +Effective Date: [Date] +Matter Number: [Matter No.] + +1. SCOPE OF REPRESENTATION + +This engagement letter confirms that Smith, Johnson & Associates LLP ("Firm") has been retained to represent [Client Name] ("Client") in connection with [Matter Description]. The scope of our representation includes: + +- Legal research and analysis of applicable federal and state laws +- Drafting and review of legal documents including contracts, pleadings, and motions +- Court appearances and oral arguments as necessary +- Settlement negotiations and mediation proceedings +- Communication with opposing counsel and third parties +- Strategic legal advice and counsel throughout the matter + +This representation does not include tax advice unless specifically agreed in writing. Any expansion of scope requires written approval from the Managing Partner and may result in adjusted fee arrangements. + +2. BILLING AND PAYMENT TERMS + +2.1 HOURLY RATES +Our current hourly rates for this matter are: +- Senior Partners: $750 per hour +- Junior Partners: $550 per hour +- Senior Associates: $450 per hour +- Junior Associates: $350 per hour +- Paralegals: $175 per hour +- Law Clerks: $125 per hour + +These rates are subject to annual adjustment. Time is billed in minimum increments of 0.1 hour (6 minutes). + +2.2 RETAINER AND TRUST ACCOUNT +Client agrees to pay an initial retainer of $25,000 upon execution of this agreement. The retainer will be deposited into our client trust account and applied against fees and costs as they are incurred. When the retainer balance falls below $5,000, Client agrees to replenish it to the original amount within 10 business days of notice. + +2.3 COSTS AND EXPENSES +Client is responsible for all costs and expenses including but not limited to: +- Court filing fees and service of process fees +- Expert witness and consultant fees +- Deposition and court reporter costs +- Travel expenses (billed at IRS standard rates) +- Document production and e-discovery costs +- Research database charges (Westlaw/Lexis) + +3. CLIENT RESPONSIBILITIES + +Client agrees to: +- Provide complete and accurate information relevant to the matter +- Respond promptly to requests for information and documents +- Make timely decisions regarding settlement and litigation strategy +- Notify the Firm immediately of any changes in contact information +- Pay all invoices within 30 days of receipt +- Maintain confidentiality of attorney-client privileged communications + +4. CONFLICTS OF INTEREST + +We have conducted a conflicts check and identified no current conflicts. Client acknowledges that the Firm represents many other clients and agrees that we may continue to represent or may undertake to represent existing or new clients in any matter that is not substantially related to our work for Client.' + +ingest_document "Client Engagement Letter Template" "$engagement_letter" '{"type": "template", "category": "engagement", "source": "firm_templates"}' + +# Document 2: Litigation Hold Notice +echo -e "${BLUE}Ingesting Litigation Hold Notice Template...${NC}" +litigation_hold='LITIGATION HOLD NOTICE +PRIVILEGED AND CONFIDENTIAL + +TO: All Employees, Officers, and Directors +FROM: General Counsel Office +DATE: [Date] +RE: Legal Hold - [Matter Name] + +IMPORTANT: MANDATORY DOCUMENT PRESERVATION NOTICE + +1. PRESERVATION OBLIGATION + +The Company is involved in pending/anticipated litigation regarding [Matter Description]. You are receiving this notice because you may have documents or electronically stored information (ESI) relevant to this matter. + +EFFECTIVE IMMEDIATELY, you must preserve ALL documents and data relating to: +- [Specific Topic 1] +- [Specific Topic 2] +- [Specific Topic 3] +- Communications with [Relevant Parties] +- Any documents dated between [Start Date] and [End Date] + +2. SCOPE OF PRESERVATION + +2.1 DOCUMENTS TO PRESERVE +Documents includes all forms of information including but not limited to: +- Emails (including drafts, sent items, and deleted items) +- Text messages, instant messages, and chat logs +- Voice mails and recorded calls +- Calendar entries and meeting invitations +- Word documents, Excel spreadsheets, PowerPoint presentations +- PDFs and scanned documents +- Photographs and videos +- Social media posts and messages +- Handwritten notes and physical files +- Database records and system logs + +2.2 LOCATIONS TO CHECK +Relevant documents may be stored in: +- Company email servers and archives +- Personal devices used for business (BYOD) +- Cloud storage (OneDrive, SharePoint, Dropbox) +- Network drives and shared folders +- Local hard drives and USB devices +- Home offices and remote work locations +- Physical filing cabinets and storage boxes + +3. SUSPENSION OF ROUTINE DESTRUCTION + +You must immediately suspend any routine document destruction policies including: +- Auto-delete functions in email systems +- Scheduled purging of archived data +- Shredding of physical documents +- Overwriting of backup tapes +- Clearing of temporary files and caches + +4. CONSEQUENCES OF NON-COMPLIANCE + +Failure to preserve relevant documents can result in: +- Severe sanctions by the court including adverse inference instructions +- Monetary penalties against the Company and individuals +- Criminal prosecution for obstruction of justice +- Disciplinary action up to and including termination +- Personal liability for spoliation of evidence + +5. DURATION OF HOLD + +This legal hold remains in effect until you receive written notice of its release from the General Counsel office. The duty to preserve continues even if you leave the Company.' + +ingest_document "Litigation Hold Notice Template" "$litigation_hold" '{"type": "template", "category": "litigation", "source": "firm_templates"}' + +# Document 3: Settlement Agreement Template +echo -e "${BLUE}Ingesting Settlement Agreement Template...${NC}" +settlement_agreement='CONFIDENTIAL SETTLEMENT AGREEMENT AND MUTUAL RELEASE + +This Settlement Agreement ("Agreement") is entered into as of [Date] by and between [Party A] ("Plaintiff") and [Party B] ("Defendant") (collectively, the "Parties"). + +RECITALS + +WHEREAS, Plaintiff filed a lawsuit against Defendant in [Court Name], Case No. [Case Number], alleging [Claims Description] (the "Litigation"); + +WHEREAS, Defendant denies all allegations and liability but desires to avoid the expense, inconvenience, and uncertainty of continued litigation; + +WHEREAS, the Parties wish to resolve all claims and disputes between them; + +NOW, THEREFORE, in consideration of the mutual covenants and agreements contained herein, and for other good and valuable consideration, the receipt and sufficiency of which are hereby acknowledged, the Parties agree as follows: + +1. SETTLEMENT PAYMENT + +1.1 Defendant agrees to pay Plaintiff the total sum of $[Amount] ("Settlement Amount") as follows: +- Initial payment of $[Amount] within 30 days of execution +- [Number] monthly installments of $[Amount] beginning [Date] +- Final payment of $[Amount] on or before [Date] + +1.2 Payments shall be made by wire transfer to the attorney trust account designated by Plaintiff counsel. Late payments shall accrue interest at 10% per annum. + +2. MUTUAL RELEASE + +2.1 PLAINTIFF RELEASE +Plaintiff hereby releases and forever discharges Defendant and its officers, directors, employees, agents, attorneys, insurers, successors, and assigns from any and all claims, demands, damages, actions, causes of action, suits, debts, costs, expenses, attorneys fees, and liabilities of any nature whatsoever, whether known or unknown, suspected or unsuspected, arising from or relating to the subject matter of the Litigation. + +2.2 DEFENDANT RELEASE +Defendant hereby releases and forever discharges Plaintiff from any and all counterclaims, cross-claims, or claims for malicious prosecution, abuse of process, or any other claims arising from the filing or prosecution of the Litigation. + +2.3 UNKNOWN CLAIMS WAIVER +The Parties expressly waive and relinquish any rights under Section 1542 of the California Civil Code (or similar statutes) which provides: A general release does not extend to claims that the creditor or releasing party does not know or suspect to exist in his or her favor at the time of executing the release. + +3. CONFIDENTIALITY + +3.1 The Parties agree that the terms of this Agreement, including the Settlement Amount, shall remain strictly confidential. The Parties shall not disclose any terms to any third party except: +- To legal and financial advisors under duty of confidentiality +- As required by law or court order +- To enforce the terms of this Agreement +- To immediate family members under obligation of confidentiality + +3.2 LIQUIDATED DAMAGES: Any breach of confidentiality shall result in liquidated damages of $50,000 per occurrence. + +4. NON-DISPARAGEMENT + +The Parties agree not to make any false, negative, or disparaging statements about each other to any third party. This provision is intended to be broadly construed and includes statements made on social media, review websites, or any other public forum.' + +ingest_document "Settlement Agreement Template" "$settlement_agreement" '{"type": "template", "category": "settlement", "source": "firm_templates"}' + +# Document 4: Firm HR Policies +echo -e "${BLUE}Ingesting Firm HR Policies...${NC}" +hr_policies='SMITH, JOHNSON & ASSOCIATES LLP +EMPLOYEE HANDBOOK AND POLICIES + +SECTION 1: WORK ARRANGEMENTS + +1.1 STANDARD WORK HOURS +Standard office hours are Monday through Friday, 9:00 AM to 6:00 PM. Partners and senior associates may have flexibility based on client needs and court schedules. + +1.2 REMOTE WORK POLICY +Remote work arrangements may be approved on a case-by-case basis. Requests must be submitted to your supervising partner and approved by the Director of Human Resources. Employees working remotely must: +- Maintain regular business hours +- Be available for video conferences +- Have secure internet connection +- Protect client confidentiality + +Contact: hr@smithlaw.com or extension 2000 + +1.3 TIME OFF AND LEAVE POLICIES + +Vacation Time: +- Associates: 15 days per year +- Senior Associates: 20 days per year +- Partners: Discretionary +- Support Staff: 10-15 days based on tenure + +Sick Leave: +- All employees: 10 days per year +- Unused sick leave does not carry over + +Personal Days: +- All employees: 3 personal days per year +- Must be approved 48 hours in advance + +SECTION 2: PROFESSIONAL DEVELOPMENT + +2.1 CONTINUING LEGAL EDUCATION (CLE) +The Firm covers all mandatory CLE requirements. Additional CLE courses may be approved if relevant to practice area. Submit requests to the Professional Development Committee. + +2.2 BAR ADMISSIONS +The Firm will cover bar examination fees and reasonable preparation costs for attorneys seeking admission in jurisdictions where the Firm practices. + +2.3 MENTORSHIP PROGRAM +All junior associates are assigned a mentor partner. Mentorship meetings should occur monthly at minimum. + +SECTION 3: BILLING AND TIMEKEEPING + +3.1 BILLABLE HOUR REQUIREMENTS +- Junior Associates: 1,800 billable hours annually +- Senior Associates: 2,000 billable hours annually +- Of Counsel: As agreed in employment contract +- Partners: No minimum requirement + +3.2 TIME ENTRY REQUIREMENTS +- All time must be entered daily +- Entries must be detailed and descriptive +- Time is recorded in 6-minute increments (0.1 hour) +- Non-billable administrative time must also be tracked + +SECTION 4: ETHICS AND COMPLIANCE + +4.1 CONFIDENTIALITY +All employees must maintain strict confidentiality regarding client matters, firm finances, and internal operations. Violations may result in immediate termination and legal action. + +4.2 CONFLICTS OF INTEREST +Employees must disclose any potential conflicts of interest immediately. Run all new matters through the conflicts checking system before engagement. + +4.3 MANDATORY REPORTING +Any suspected ethical violations, discrimination, or harassment must be reported immediately to Human Resources or the Managing Partner. + +For all HR-related questions or concerns, please contact: +Human Resources Department +hr@smithlaw.com +Extension: 2000 +Office: Suite 500' + +ingest_document "Firm HR Policies" "$hr_policies" '{"type": "policy", "category": "hr", "source": "internal_policies"}' + +# Document 5: Legal Research Procedures +echo -e "${BLUE}Ingesting Legal Research Procedures...${NC}" +research_procedures='LEGAL RESEARCH PROCEDURES AND BEST PRACTICES + +1. RESEARCH METHODOLOGY + +1.1 PRIMARY SOURCES +Always begin with primary sources: +- Constitutions (federal and state) +- Statutes and codes +- Regulations and administrative rules +- Case law from relevant jurisdictions +- Court rules and local rules + +1.2 SECONDARY SOURCES +Use secondary sources for context and analysis: +- Legal treatises and practice guides +- Law review articles +- ALR annotations +- Restatements +- Legal encyclopedias (AmJur, CJS) + +1.3 RESEARCH DATABASES +The Firm maintains subscriptions to: +- Westlaw (primary platform) +- Lexis Advance +- Bloomberg Law (securities matters) +- PACER (federal court filings) + +2. RESEARCH WORKFLOW + +2.1 INITIAL ASSESSMENT +- Define the legal issue precisely +- Identify relevant jurisdiction(s) +- Determine applicable time period +- Note any special procedural requirements + +2.2 RESEARCH PLAN +- Create a research plan before beginning +- Set time limits for each research task +- Document search terms and databases used +- Keep detailed notes of findings + +2.3 VERIFICATION +- Shepardize or KeyCite all cases +- Verify current status of statutes +- Check for recent amendments or updates +- Confirm local rule compliance + +3. MEMORANDUM FORMAT + +3.1 STRUCTURE +All research memoranda should include: +- Question Presented +- Brief Answer +- Statement of Facts +- Discussion/Analysis +- Conclusion +- Citations in Bluebook format + +3.2 CITATION REQUIREMENTS +- Use Bluebook citation format (current edition) +- Include pinpoint citations +- Provide parallel citations where required +- Hyperlink to cases in electronic documents + +4. QUALITY CONTROL + +4.1 PEER REVIEW +Research memoranda over 10 pages must be peer-reviewed before submission to partners. + +4.2 SUPERVISING ATTORNEY APPROVAL +All research must be approved by the supervising attorney before being incorporated into client work product. + +4.3 TIME TRACKING +Research time must be tracked with specificity: +- Note databases searched +- Record specific issues researched +- Distinguish between billable and non-billable research + +For research support, contact the Law Library: +library@smithlaw.com +Extension: 2100' + +ingest_document "Legal Research Procedures" "$research_procedures" '{"type": "procedure", "category": "research", "source": "internal_procedures"}' + +echo -e "${GREEN}========================================${NC}" +echo -e "${GREEN}Document Ingestion Complete!${NC}" +echo -e "${GREEN}========================================${NC}" + +# Test the knowledge base +echo -e "${BLUE}Testing knowledge base...${NC}" + +test_query() { + local query=$1 + echo -e "${YELLOW}Testing query: $query${NC}" + + response=$(curl -k -s -X POST "${API_URL}/chat/" \ + -H "Content-Type: application/json" \ + -d "{\"message\": \"$query\"}") + + if echo "$response" | grep -q "response"; then + echo -e "${GREEN}āœ“ Query successful${NC}" + echo "$response" | python3 -m json.tool | head -20 + else + echo -e "${RED}āœ— Query failed${NC}" + fi +} + +echo "" +test_query "What are the billing rates for attorneys?" +echo "" +test_query "What is the retainer amount for new clients?" +echo "" +test_query "Who should I contact for HR matters?" + +echo -e "${BLUE}========================================${NC}" +echo -e "${GREEN}Your AWS deployment now has the same knowledge base as your MacBook!${NC}" +echo -e "${BLUE}========================================${NC}" diff --git a/backend/aws_manage_ip.sh b/backend/aws_manage_ip.sh new file mode 100755 index 0000000..75d950e --- /dev/null +++ b/backend/aws_manage_ip.sh @@ -0,0 +1,145 @@ +#!/bin/bash + +# AWS EC2 IP Management Script +# Helps manage dynamic IP addresses for your EC2 instance + +CONFIG_FILE="$HOME/.privategpt_ec2_config" +SSH_KEY="$HOME/.ssh/Scott-Key.pem" +SSH_USER="ec2-user" + +# Colors for output +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' # No Color + +# Function to save IP +save_ip() { + local ip=$1 + echo "EC2_HOST=$ip" > "$CONFIG_FILE" + echo "LAST_UPDATED=$(date '+%Y-%m-%d %H:%M:%S')" >> "$CONFIG_FILE" + echo -e "${GREEN}āœ“ IP address saved: $ip${NC}" +} + +# Function to load saved IP +load_ip() { + if [ -f "$CONFIG_FILE" ]; then + source "$CONFIG_FILE" + echo -e "${BLUE}Last saved IP: $EC2_HOST${NC}" + echo "Last updated: $LAST_UPDATED" + return 0 + else + echo "No saved IP address found." + return 1 + fi +} + +# Main menu +echo "===========================================" +echo "Private GPT EC2 IP Manager" +echo "===========================================" +echo "" + +# Check if we have a saved IP +if [ -f "$CONFIG_FILE" ]; then + source "$CONFIG_FILE" + echo "Last known IP: $EC2_HOST" + echo "Last updated: $LAST_UPDATED" + echo "" + echo "Options:" + echo "1) Use saved IP ($EC2_HOST)" + echo "2) Enter new IP" + echo "3) Get IP from AWS CLI (requires configured AWS CLI)" + read -p "Choice [1-3]: " choice +else + echo "No saved IP found." + echo "" + echo "Options:" + echo "2) Enter new IP manually" + echo "3) Get IP from AWS CLI (requires configured AWS CLI)" + read -p "Choice [2-3]: " choice +fi + +case $choice in + 1) + if [ -z "$EC2_HOST" ]; then + echo "No saved IP available. Please enter IP manually." + read -p "IP Address: " EC2_HOST + fi + ;; + 2) + read -p "Enter new IP address: " EC2_HOST + ;; + 3) + echo "Attempting to get IP from AWS CLI..." + echo "Enter your instance ID:" + read -p "Instance ID: " INSTANCE_ID + EC2_HOST=$(aws ec2 describe-instances \ + --instance-ids "$INSTANCE_ID" \ + --query 'Reservations[0].Instances[0].PublicIpAddress' \ + --output text 2>/dev/null) + + if [ "$EC2_HOST" = "None" ] || [ -z "$EC2_HOST" ]; then + echo "Could not retrieve IP. Is the instance running?" + exit 1 + fi + echo -e "${GREEN}Retrieved IP: $EC2_HOST${NC}" + ;; + *) + echo "Invalid choice" + exit 1 + ;; +esac + +# Validate IP format +if [[ ! $EC2_HOST =~ ^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$ ]]; then + echo "Invalid IP address format: $EC2_HOST" + exit 1 +fi + +# Save the IP for next time +save_ip "$EC2_HOST" + +echo "" +echo "Testing connection to $EC2_HOST..." +if ssh -i "$SSH_KEY" -o ConnectTimeout=5 "$SSH_USER@$EC2_HOST" "echo 'Connected successfully'" > /dev/null 2>&1; then + echo -e "${GREEN}āœ“ Connection successful!${NC}" + echo "" + echo "What would you like to do?" + echo "1) Run startup check" + echo "2) Run auto-recovery" + echo "3) SSH into instance" + echo "4) Open web interface in browser" + echo "5) Exit" + read -p "Choice [1-5]: " action + + case $action in + 1) + echo "$EC2_HOST" | ./aws_startup_check.sh + ;; + 2) + echo "$EC2_HOST" | ./aws_auto_recovery.sh + ;; + 3) + ssh -i "$SSH_KEY" "$SSH_USER@$EC2_HOST" + ;; + 4) + echo "Opening https://$EC2_HOST/ in your default browser..." + echo "(You'll need to accept the self-signed certificate warning)" + open "https://$EC2_HOST/" 2>/dev/null || xdg-open "https://$EC2_HOST/" 2>/dev/null || echo "Please open manually: https://$EC2_HOST/" + ;; + 5) + exit 0 + ;; + *) + echo "Invalid choice" + ;; + esac +else + echo -e "${YELLOW}āš  Cannot connect to $EC2_HOST${NC}" + echo "" + echo "Please check:" + echo "1. Instance is running in AWS Console" + echo "2. Security group allows SSH (port 22) from your IP" + echo "3. The IP address is correct" +fi diff --git a/backend/aws_startup_check.sh b/backend/aws_startup_check.sh new file mode 100755 index 0000000..7c7f76a --- /dev/null +++ b/backend/aws_startup_check.sh @@ -0,0 +1,179 @@ +#!/bin/bash + +# AWS EC2 Private GPT System Startup Checklist and Diagnostic Script +# Run this after bringing up your EC2 instance to verify all services + +set -e + +echo "===========================================" +echo "Private GPT System Startup Check" +echo "===========================================" +echo "" + +# Get IP from parameter, stdin, or prompt +if [ -n "$1" ]; then + EC2_HOST="$1" +elif [ ! -t 0 ]; then + # Read from stdin if available + read EC2_HOST +else + # Prompt for EC2 IP address + echo "Enter your EC2 instance public IP address:" + echo "(You can find this in AWS Console under EC2 > Instances)" + read -p "IP Address: " EC2_HOST +fi + +# Validate IP address format +if [[ ! $EC2_HOST =~ ^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$ ]]; then + echo "Invalid IP address format: $EC2_HOST" + exit 1 +fi + +# Configuration +SSH_KEY="$HOME/.ssh/Scott-Key.pem" +SSH_USER="ec2-user" + +echo "" +echo "Using EC2 instance at: $EC2_HOST" + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +NC='\033[0m' # No Color + +# Function to check status +check_status() { + if [ $1 -eq 0 ]; then + echo -e "${GREEN}āœ“${NC} $2" + else + echo -e "${RED}āœ—${NC} $2" + return 1 + fi +} + +# Function to run remote command +run_remote() { + ssh -i "$SSH_KEY" "$SSH_USER@$EC2_HOST" "$1" +} + +echo "1. Checking SSH connectivity..." +if ssh -i "$SSH_KEY" -o ConnectTimeout=5 "$SSH_USER@$EC2_HOST" "echo 'SSH connection successful'" > /dev/null 2>&1; then + echo -e "${GREEN}āœ“${NC} SSH connection established" +else + echo -e "${RED}āœ—${NC} Cannot connect via SSH. Please check:" + echo " - Instance is running in AWS Console" + echo " - Security group allows SSH (port 22)" + echo " - Public IP is correct: $EC2_HOST" + exit 1 +fi + +echo "" +echo "2. Checking system services..." + +# Check backend service +echo -n " Backend service (privategpt-backend): " +BACKEND_STATUS=$(run_remote "sudo systemctl is-active privategpt-backend 2>/dev/null || echo 'inactive'") +if [ "$BACKEND_STATUS" = "active" ]; then + echo -e "${GREEN}Active${NC}" +else + echo -e "${RED}$BACKEND_STATUS${NC}" + echo " To start: ssh -i $SSH_KEY $SSH_USER@$EC2_HOST 'sudo systemctl start privategpt-backend'" +fi + +# Check nginx +echo -n " Nginx service: " +NGINX_STATUS=$(run_remote "sudo systemctl is-active nginx 2>/dev/null || echo 'inactive'") +if [ "$NGINX_STATUS" = "active" ]; then + echo -e "${GREEN}Active${NC}" +else + echo -e "${RED}$NGINX_STATUS${NC}" + echo " To start: ssh -i $SSH_KEY $SSH_USER@$EC2_HOST 'sudo systemctl start nginx'" +fi + +echo "" +echo "3. Checking backend API health..." +# Check backend directly on port 8000 +BACKEND_HEALTH=$(run_remote "curl -s -o /dev/null -w '%{http_code}' http://localhost:8000/api/health 2>/dev/null || echo '000'") +if [ "$BACKEND_HEALTH" = "200" ]; then + echo -e "${GREEN}āœ“${NC} Backend API responding on port 8000" +else + echo -e "${RED}āœ—${NC} Backend API not responding (HTTP $BACKEND_HEALTH)" + echo " Checking logs..." + run_remote "sudo journalctl -u privategpt-backend -n 10 --no-pager" 2>/dev/null || echo " Could not retrieve logs" +fi + +echo "" +echo "4. Checking Nginx proxy..." +# Check nginx proxy to backend +PROXY_HEALTH=$(curl -k -s -o /dev/null -w '%{http_code}' "https://$EC2_HOST/api/health" 2>/dev/null || echo '000') +if [ "$PROXY_HEALTH" = "200" ]; then + echo -e "${GREEN}āœ“${NC} Nginx proxy to backend working" +else + echo -e "${RED}āœ—${NC} Nginx proxy not working (HTTP $PROXY_HEALTH)" +fi + +echo "" +echo "5. Checking frontend..." +FRONTEND_STATUS=$(curl -k -s -o /dev/null -w '%{http_code}' "https://$EC2_HOST/" 2>/dev/null || echo '000') +if [ "$FRONTEND_STATUS" = "200" ]; then + echo -e "${GREEN}āœ“${NC} Frontend accessible" +else + echo -e "${YELLOW}āš ${NC} Frontend returned HTTP $FRONTEND_STATUS" +fi + +echo "" +echo "6. Checking environment variables..." +ENV_CHECK=$(run_remote "cat /home/ec2-user/privategpt-backend/.env 2>/dev/null | grep -c '=' || echo '0'") +if [ "$ENV_CHECK" -gt 0 ]; then + echo -e "${GREEN}āœ“${NC} Environment file exists with $ENV_CHECK variables" + echo " Key variables:" + run_remote "cat /home/ec2-user/privategpt-backend/.env | grep -E '^(AWS_REGION|BEDROCK_MODEL_ID|PINECONE_INDEX_NAME)' | sed 's/=.*/=***/' | sed 's/^/ /'" +else + echo -e "${RED}āœ—${NC} Environment file missing or empty" +fi + +echo "" +echo "7. Checking Pinecone connection..." +PINECONE_TEST=$(run_remote "cd /home/ec2-user/privategpt-backend && python3 -c 'from app.services.vector_service import VectorService; import asyncio; vs = VectorService(); print(\"OK\" if vs.index else \"FAIL\")' 2>/dev/null || echo 'ERROR'") +if [ "$PINECONE_TEST" = "OK" ]; then + echo -e "${GREEN}āœ“${NC} Pinecone connection established" +else + echo -e "${RED}āœ—${NC} Pinecone connection failed" +fi + +echo "" +echo "8. Testing chat endpoint..." +CHAT_TEST=$(curl -k -s -X POST "https://$EC2_HOST/api/chat/" \ + -H "Content-Type: application/json" \ + -d '{"message":"Hello","session_id":"test"}' \ + -w '\n%{http_code}' 2>/dev/null | tail -1) +if [ "$CHAT_TEST" = "200" ]; then + echo -e "${GREEN}āœ“${NC} Chat API responding correctly" +else + echo -e "${RED}āœ—${NC} Chat API returned HTTP $CHAT_TEST" +fi + +echo "" +echo "===========================================" +echo "QUICK FIX COMMANDS:" +echo "===========================================" +echo "" +echo "# Connect to instance:" +echo "ssh -i $SSH_KEY $SSH_USER@$EC2_HOST" +echo "" +echo "# Restart all services:" +echo "ssh -i $SSH_KEY $SSH_USER@$EC2_HOST 'sudo systemctl restart privategpt-backend nginx'" +echo "" +echo "# Check backend logs:" +echo "ssh -i $SSH_KEY $SSH_USER@$EC2_HOST 'sudo journalctl -u privategpt-backend -f'" +echo "" +echo "# Check nginx logs:" +echo "ssh -i $SSH_KEY $SSH_USER@$EC2_HOST 'sudo tail -f /var/log/nginx/error.log'" +echo "" +echo "# Test backend directly:" +echo "ssh -i $SSH_KEY $SSH_USER@$EC2_HOST 'curl http://localhost:8000/api/health'" +echo "" +echo "# Access the UI:" +echo "https://$EC2_HOST/" +echo "" diff --git a/backend/aws_sync_deployment.sh b/backend/aws_sync_deployment.sh new file mode 100755 index 0000000..23941d7 --- /dev/null +++ b/backend/aws_sync_deployment.sh @@ -0,0 +1,291 @@ +#!/bin/bash + +# AWS EC2 Deployment Sync Script +# Purpose: Ensure AWS deployment matches MacBook configuration exactly +# Author: Scott Steele System +# Date: December 2024 + +set -e # Exit on error + +# Color codes for output +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' # No Color + +# Configuration +KEY_PATH="$HOME/.ssh/Scott-Key.pem" +LOCAL_BACKEND_PATH="/Users/scottsteele/privategpt-ui/backend" +LOCAL_FRONTEND_PATH="/Users/scottsteele/privategpt-ui" + +echo -e "${BLUE}========================================${NC}" +echo -e "${BLUE}AWS EC2 Private GPT Deployment Sync${NC}" +echo -e "${BLUE}========================================${NC}" + +# Function to check if EC2 instance is reachable +check_ec2_connection() { + local ip=$1 + echo -e "${YELLOW}Testing connection to EC2 instance at $ip...${NC}" + if ssh -o ConnectTimeout=5 -o StrictHostKeyChecking=no -i "$KEY_PATH" ec2-user@"$ip" "echo 'Connected'" > /dev/null 2>&1; then + echo -e "${GREEN}āœ“ Successfully connected to EC2 instance${NC}" + return 0 + else + echo -e "${RED}āœ— Cannot connect to EC2 instance${NC}" + return 1 + fi +} + +# Get EC2 IP +if [ -z "$1" ]; then + echo -e "${YELLOW}Please enter your EC2 instance public IP address:${NC}" + read -r EC2_IP +else + EC2_IP=$1 +fi + +# Validate connection +if ! check_ec2_connection "$EC2_IP"; then + echo -e "${RED}Cannot proceed without EC2 connection${NC}" + exit 1 +fi + +echo -e "${GREEN}Connected to EC2 at $EC2_IP${NC}" + +# Create deployment package with exact MacBook configuration +echo -e "${BLUE}Creating deployment package...${NC}" + +# Create temp directory for deployment +TEMP_DIR=$(mktemp -d) +DEPLOY_DIR="$TEMP_DIR/privategpt-deploy" +mkdir -p "$DEPLOY_DIR" + +# Copy backend files +echo -e "${YELLOW}Copying backend files...${NC}" +cp -r "$LOCAL_BACKEND_PATH/app" "$DEPLOY_DIR/" +cp "$LOCAL_BACKEND_PATH/requirements.txt" "$DEPLOY_DIR/" 2>/dev/null || true +cp "$LOCAL_BACKEND_PATH/.env" "$DEPLOY_DIR/" + +# Copy frontend build (if exists) +if [ -d "$LOCAL_FRONTEND_PATH/dist" ]; then + echo -e "${YELLOW}Copying frontend build...${NC}" + cp -r "$LOCAL_FRONTEND_PATH/dist" "$DEPLOY_DIR/frontend" +fi + +# Create requirements.txt if it doesn't exist +if [ ! -f "$DEPLOY_DIR/requirements.txt" ]; then + echo -e "${YELLOW}Creating requirements.txt...${NC}" + cat > "$DEPLOY_DIR/requirements.txt" << 'EOF' +fastapi==0.116.1 +uvicorn[standard]==0.35.0 +python-dotenv==1.1.1 +boto3==1.40.3 +pinecone[grpc]==7.3.0 +python-multipart==0.0.20 +httpx==0.28.1 +aiofiles==24.1.0 +pydantic==2.10.6 +EOF +fi + +# Create deployment script +cat > "$DEPLOY_DIR/deploy.sh" << 'DEPLOY_SCRIPT' +#!/bin/bash + +# AWS EC2 Deployment Script +set -e + +echo "Starting deployment on EC2..." + +# Update system +sudo yum update -y + +# Install Python 3.11 if not present +if ! command -v python3.11 &> /dev/null; then + echo "Installing Python 3.11..." + sudo yum install -y python3.11 python3.11-pip +fi + +# Install Node.js if not present (for frontend) +if ! command -v node &> /dev/null; then + echo "Installing Node.js..." + curl -sL https://rpm.nodesource.com/setup_18.x | sudo bash - + sudo yum install -y nodejs +fi + +# Install nginx if not present +if ! command -v nginx &> /dev/null; then + echo "Installing nginx..." + sudo yum install -y nginx +fi + +# Setup backend +echo "Setting up backend..." +cd /home/ec2-user + +# Stop existing backend service +sudo systemctl stop privategpt-backend 2>/dev/null || true + +# Remove old backend directory +rm -rf privategpt-backend-old +[ -d privategpt-backend ] && mv privategpt-backend privategpt-backend-old + +# Create new backend directory +mkdir -p privategpt-backend +cp -r /tmp/deploy/app privategpt-backend/ +cp /tmp/deploy/.env privategpt-backend/ +cp /tmp/deploy/requirements.txt privategpt-backend/ + +# Create virtual environment +cd privategpt-backend +python3.11 -m venv venv +source venv/bin/activate + +# Install dependencies +pip install --upgrade pip +pip install -r requirements.txt + +# Create systemd service for backend +sudo tee /etc/systemd/system/privategpt-backend.service > /dev/null << 'SERVICE' +[Unit] +Description=PrivateGPT Backend API +After=network.target + +[Service] +Type=simple +User=ec2-user +WorkingDirectory=/home/ec2-user/privategpt-backend +Environment="PATH=/home/ec2-user/privategpt-backend/venv/bin" +ExecStart=/home/ec2-user/privategpt-backend/venv/bin/uvicorn app.main:app --host 0.0.0.0 --port 8000 +Restart=always +RestartSec=10 + +[Install] +WantedBy=multi-user.target +SERVICE + +# Setup frontend (if provided) +if [ -d /tmp/deploy/frontend ]; then + echo "Setting up frontend..." + sudo rm -rf /usr/share/nginx/html/* + sudo cp -r /tmp/deploy/frontend/* /usr/share/nginx/html/ + sudo chown -R nginx:nginx /usr/share/nginx/html +fi + +# Configure nginx +sudo tee /etc/nginx/conf.d/privategpt.conf > /dev/null << 'NGINX' +server { + listen 80; + server_name _; + + # Frontend + location / { + root /usr/share/nginx/html; + try_files $uri $uri/ /index.html; + } + + # Backend API proxy + location /api/ { + proxy_pass http://localhost:8000/api/; + proxy_http_version 1.1; + proxy_set_header Upgrade $http_upgrade; + proxy_set_header Connection 'upgrade'; + proxy_set_header Host $host; + proxy_cache_bypass $http_upgrade; + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Forwarded-Proto $scheme; + } +} + +server { + listen 443 ssl; + server_name _; + + ssl_certificate /etc/nginx/ssl/cert.pem; + ssl_certificate_key /etc/nginx/ssl/key.pem; + + # Frontend + location / { + root /usr/share/nginx/html; + try_files $uri $uri/ /index.html; + } + + # Backend API proxy + location /api/ { + proxy_pass http://localhost:8000/api/; + proxy_http_version 1.1; + proxy_set_header Upgrade $http_upgrade; + proxy_set_header Connection 'upgrade'; + proxy_set_header Host $host; + proxy_cache_bypass $http_upgrade; + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Forwarded-Proto $scheme; + } +} +NGINX + +# Create SSL certificate if not exists +if [ ! -f /etc/nginx/ssl/cert.pem ]; then + sudo mkdir -p /etc/nginx/ssl + sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 \ + -keyout /etc/nginx/ssl/key.pem \ + -out /etc/nginx/ssl/cert.pem \ + -subj "/C=US/ST=State/L=City/O=Organization/CN=localhost" +fi + +# Reload systemd and start services +sudo systemctl daemon-reload +sudo systemctl enable privategpt-backend +sudo systemctl start privategpt-backend +sudo systemctl enable nginx +sudo systemctl restart nginx + +echo "Deployment complete!" +echo "Backend status:" +sudo systemctl status privategpt-backend --no-pager | head -10 +echo "" +echo "Testing backend health..." +sleep 5 +curl -s http://localhost:8000/api/health || echo "Backend not responding yet" +DEPLOY_SCRIPT + +chmod +x "$DEPLOY_DIR/deploy.sh" + +# Create tarball +echo -e "${YELLOW}Creating deployment archive...${NC}" +cd "$TEMP_DIR" +tar -czf privategpt-deploy.tar.gz privategpt-deploy/ + +# Upload to EC2 +echo -e "${BLUE}Uploading to EC2...${NC}" +scp -i "$KEY_PATH" privategpt-deploy.tar.gz ec2-user@"$EC2_IP":/tmp/ + +# Deploy on EC2 +echo -e "${BLUE}Running deployment on EC2...${NC}" +ssh -i "$KEY_PATH" ec2-user@"$EC2_IP" << 'REMOTE_COMMANDS' +set -e +cd /tmp +rm -rf deploy +tar -xzf privategpt-deploy.tar.gz +mv privategpt-deploy deploy +cd deploy +chmod +x deploy.sh +./deploy.sh +REMOTE_COMMANDS + +# Cleanup +rm -rf "$TEMP_DIR" + +echo -e "${GREEN}========================================${NC}" +echo -e "${GREEN}Deployment Sync Complete!${NC}" +echo -e "${GREEN}========================================${NC}" +echo "" +echo -e "${YELLOW}Next steps:${NC}" +echo "1. Test the backend API: https://$EC2_IP/api/health" +echo "2. Test the frontend: https://$EC2_IP" +echo "3. Run document ingestion script" +echo "" +echo -e "${BLUE}To ingest documents, run:${NC}" +echo " ./aws_ingest_documents.sh $EC2_IP" diff --git a/backend/backend/app/services/__init__.py b/backend/backend/app/services/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/backend/check_kb_size.py b/backend/check_kb_size.py new file mode 100644 index 0000000..f1fed9d --- /dev/null +++ b/backend/check_kb_size.py @@ -0,0 +1,35 @@ +#!/usr/bin/env python3 +import asyncio +import os +import sys +sys.path.append('/home/ec2-user/privategpt/backend') +from app.services.vector_service import vector_service + +async def check_kb_stats(): + stats = await vector_service.get_index_stats() + print("Knowledge Base Statistics:") + print("=" * 50) + print(f"Total vectors stored: {stats.get('total_vector_count', 0)}") + print(f"Index dimension: {stats.get('dimension', 0)}") + print(f"Index fullness: {stats.get('index_fullness', 0):.2%}") + + # Each vector represents a chunk of text + # Assuming average chunk size of ~500 tokens + total_vectors = stats.get('total_vector_count', 0) + estimated_tokens = total_vectors * 500 + estimated_words = estimated_tokens * 0.75 # rough conversion + + print(f"\nEstimated content size:") + print(f" ~{estimated_tokens:,} tokens") + print(f" ~{estimated_words:,.0f} words") + print(f" ~{estimated_words/250:.0f} pages (assuming 250 words/page)") + + # Also show namespaces if any + namespaces = stats.get('namespaces', {}) + if namespaces: + print(f"\nNamespaces:") + for ns_name, ns_stats in namespaces.items(): + print(f" {ns_name}: {ns_stats.get('vector_count', 0)} vectors") + +if __name__ == "__main__": + asyncio.run(check_kb_stats()) diff --git a/backend/ingest_clean_documents.py b/backend/ingest_clean_documents.py new file mode 100644 index 0000000..c8ad032 --- /dev/null +++ b/backend/ingest_clean_documents.py @@ -0,0 +1,367 @@ +#!/usr/bin/env python3 +""" +Ingest clean legal documents without problematic content +Removes Dan Pfeiffer references and template placeholders +""" + +import requests +import json + +BASE_URL = "http://localhost:8000" + +def ingest_clean_documents(): + """Ingest clean legal documents for better testing""" + + # Document 1: Clean Engagement Letter + engagement_letter = """ + SMITH, JOHNSON & ASSOCIATES LLP + ATTORNEY-CLIENT ENGAGEMENT AGREEMENT + + Effective Date: January 1, 2024 + Matter Number: 2024-001 + + 1. SCOPE OF REPRESENTATION + + This engagement letter confirms that Smith, Johnson & Associates LLP ("Firm") has been retained to represent you in connection with your business legal matters. The scope of our representation includes: + + - Legal research and analysis of applicable federal and state laws + - Drafting and review of legal documents including contracts, pleadings, and motions + - Court appearances and oral arguments as necessary + - Settlement negotiations and mediation proceedings + - Communication with opposing counsel and third parties + - Strategic legal advice and counsel throughout the matter + + This representation does not include tax advice unless specifically agreed in writing. Any expansion of scope requires written approval and may result in adjusted fee arrangements. + + 2. BILLING AND PAYMENT TERMS + + 2.1 HOURLY RATES + Our current hourly rates for this matter are: + - Senior Partners: $750 per hour + - Junior Partners: $550 per hour + - Senior Associates: $450 per hour + - Junior Associates: $350 per hour + - Paralegals: $175 per hour + - Law Clerks: $125 per hour + + These rates are subject to annual adjustment. Time is billed in minimum increments of 0.1 hour (6 minutes). + + 2.2 RETAINER AND TRUST ACCOUNT + Client agrees to pay an initial retainer of $25,000 upon execution of this agreement. The retainer will be deposited into our client trust account and applied against fees and costs as they are incurred. When the retainer balance falls below $5,000, Client agrees to replenish it to the original amount within 10 business days of notice. + + 2.3 COSTS AND EXPENSES + Client is responsible for all costs and expenses including but not limited to: + - Court filing fees and service of process fees + - Expert witness and consultant fees + - Deposition and court reporter costs + - Travel expenses (billed at IRS standard rates) + - Document production and e-discovery costs + - Research database charges (Westlaw/Lexis) + + 3. CLIENT RESPONSIBILITIES + + Client agrees to: + - Provide complete and accurate information relevant to the matter + - Respond promptly to requests for information and documents + - Make timely decisions regarding settlement and litigation strategy + - Notify the Firm immediately of any changes in contact information + - Pay all invoices within 30 days of receipt + - Maintain confidentiality of attorney-client privileged communications + + 4. CONFLICTS OF INTEREST + + We have conducted a conflicts check and identified no current conflicts. Client acknowledges that the Firm represents many other clients and agrees that we may continue to represent or may undertake to represent existing or new clients in any matter that is not substantially related to our work for Client. + """ + + # Document 2: Clean Litigation Hold Notice + litigation_hold = """ + LITIGATION HOLD NOTICE + PRIVILEGED AND CONFIDENTIAL + + TO: All Employees, Officers, and Directors + FROM: General Counsel's Office + DATE: January 15, 2024 + RE: Legal Hold - Smith v. Jones Matter + + IMPORTANT: MANDATORY DOCUMENT PRESERVATION NOTICE + + 1. PRESERVATION OBLIGATION + + The Company is involved in pending litigation regarding contract dispute matters. You are receiving this notice because you may have documents or electronically stored information (ESI) relevant to this matter. + + EFFECTIVE IMMEDIATELY, you must preserve ALL documents and data relating to: + - All contracts with ABC Corporation from 2020-2024 + - Communications regarding the Project Alpha development + - Financial records related to the disputed transactions + - All emails with the domain @abccorp.com + - Any documents dated between January 1, 2020 and December 31, 2023 + + 2. SCOPE OF PRESERVATION + + Documents includes all forms of information including but not limited to: + - Emails (including drafts, sent items, and deleted items) + - Text messages, instant messages, and chat logs + - Voice mails and recorded calls + - Calendar entries and meeting invitations + - Word documents, Excel spreadsheets, PowerPoint presentations + - PDFs and scanned documents + - Photographs and videos + - Social media posts and messages + - Handwritten notes and physical files + - Database records and system logs + + 3. SUSPENSION OF ROUTINE DESTRUCTION + + You must immediately suspend any routine document destruction policies including: + - Auto-delete functions in email systems + - Scheduled purging of archived data + - Shredding of physical documents + - Overwriting of backup tapes + - Clearing of temporary files and caches + + 4. CONSEQUENCES OF NON-COMPLIANCE + + Failure to preserve relevant documents can result in: + - Severe sanctions by the court including adverse inference instructions + - Monetary penalties against the Company and individuals + - Criminal prosecution for obstruction of justice + - Disciplinary action up to and including termination + - Personal liability for spoliation of evidence + + 5. DURATION OF HOLD + + This legal hold remains in effect until you receive written notice of its release from the General Counsel's office. The duty to preserve continues even if you leave the Company. + """ + + # Document 3: Clean Settlement Agreement + settlement_agreement = """ + CONFIDENTIAL SETTLEMENT AGREEMENT AND MUTUAL RELEASE + + This Settlement Agreement ("Agreement") is entered into as of February 1, 2024 by and between ABC Corporation ("Plaintiff") and XYZ Industries ("Defendant") (collectively, the "Parties"). + + RECITALS + + WHEREAS, Plaintiff filed a lawsuit against Defendant in the Superior Court of California, Case No. 2023-CV-12345, alleging breach of contract and related claims; + + WHEREAS, Defendant denies all allegations and liability but desires to avoid the expense, inconvenience, and uncertainty of continued litigation; + + WHEREAS, the Parties wish to resolve all claims and disputes between them; + + NOW, THEREFORE, in consideration of the mutual covenants and agreements contained herein, the Parties agree as follows: + + 1. SETTLEMENT PAYMENT + + 1.1 Defendant agrees to pay Plaintiff the total sum of $500,000 as follows: + - Initial payment of $250,000 within 30 days of execution + - Six monthly installments of $41,666.67 beginning March 1, 2024 + - Final payment of $41,666.67 on or before September 1, 2024 + + 1.2 Payments shall be made by wire transfer to the attorney trust account designated by Plaintiff's counsel. Late payments shall accrue interest at 10% per annum. + + 2. MUTUAL RELEASE + + 2.1 PLAINTIFF'S RELEASE + Plaintiff hereby releases and forever discharges Defendant and its officers, directors, employees, agents, attorneys, insurers, successors, and assigns from any and all claims, demands, damages, actions, causes of action, suits, debts, costs, expenses, attorneys' fees, and liabilities of any nature whatsoever, whether known or unknown, suspected or unsuspected, arising from or relating to the subject matter of the Litigation. + + 2.2 DEFENDANT'S RELEASE + Defendant hereby releases and forever discharges Plaintiff from any and all counterclaims, cross-claims, or claims for malicious prosecution, abuse of process, or any other claims arising from the filing or prosecution of the Litigation. + + 3. CONFIDENTIALITY + + 3.1 The Parties agree that the terms of this Agreement, including the Settlement Amount, shall remain strictly confidential. The Parties shall not disclose any terms to any third party except: + - To legal and financial advisors under duty of confidentiality + - As required by law or court order + - To enforce the terms of this Agreement + + 3.2 LIQUIDATED DAMAGES: Any breach of confidentiality shall result in liquidated damages of $50,000 per occurrence. + + 4. NON-DISPARAGEMENT + + The Parties agree not to make any false, negative, or disparaging statements about each other to any third party. This provision is intended to be broadly construed and includes statements made on social media, review websites, or any other public forum. + + 5. DISMISSAL OF LITIGATION + + Within 5 business days of receipt of the initial settlement payment, Plaintiff shall file a dismissal with prejudice of all claims against Defendant. Each party shall bear its own costs and attorneys' fees. + """ + + # Document 4: Clean Legal Research Memo on Personal Jurisdiction + research_memo = """ + MEMORANDUM + + TO: Senior Partner + FROM: Associate Attorney + DATE: February 15, 2024 + RE: Personal Jurisdiction in Internet Defamation Cases + CLIENT: Tech Innovations Inc. + MATTER NO: 2024-TI-001 + + QUESTION PRESENTED + + Whether a California court may exercise personal jurisdiction over an out-of-state defendant who allegedly posted defamatory content on social media platforms accessible in California but who has no other contacts with the state. + + BRIEF ANSWER + + Yes. California courts may exercise specific personal jurisdiction over a non-resident defendant in an internet defamation case if: (1) the defendant purposefully directed the defamatory content at California; (2) the plaintiff suffered harm in California; and (3) the claim arises from the defendant's forum-related activities. Under the effects test established in Calder v. Jones, courts focus on where the harm was suffered rather than where the defendant acted. + + STATEMENT OF FACTS + + Our client, a California resident and business owner, discovered defamatory posts about their business practices on Twitter, Facebook, and Yelp. The posts were made by a competitor based in Nevada who has never physically entered California. The posts specifically reference our client's California location and customer base. Our client has experienced a 30% decrease in revenue since the posts appeared. + + DISCUSSION + + I. CALIFORNIA'S LONG-ARM STATUTE + + California's long-arm statute extends jurisdiction to the full extent permitted by the Due Process Clause of the Fourteenth Amendment. Cal. Civ. Proc. Code Ā§ 410.10. Therefore, the jurisdictional analysis merges with the federal constitutional analysis. + + II. SPECIFIC PERSONAL JURISDICTION ANALYSIS + + The Ninth Circuit applies a three-prong test for specific jurisdiction: + + A. Purposeful Direction + The defendant must have either purposefully directed activities at the forum or purposefully availed themselves of the forum's benefits. For intentional torts like defamation, courts apply the purposeful direction test from Calder v. Jones, 465 U.S. 783 (1984). + + Under Calder's effects test, purposeful direction exists when: + 1. The defendant committed an intentional act; + 2. The act was expressly aimed at the forum state; + 3. The act caused harm that the defendant knew was likely to be suffered in the forum. + + Recent cases applying this test to internet defamation: + - Mavrix Photo, Inc. v. Brand Techs., Inc., 647 F.3d 1218 (9th Cir. 2011): Posting content on nationally accessible website insufficient without "something more" + - Clemens v. McNamee, 615 F.3d 374 (5th Cir. 2010): Statements to national media about plaintiff known to reside in forum sufficient + + B. Arising From Forum-Related Activities + The claim must arise out of or relate to the defendant's contacts with California. This element is clearly satisfied in defamation cases where the alleged defamatory statements constitute the contacts. + + C. Reasonableness + Exercise of jurisdiction must be reasonable, considering: + - Burden on defendant + - Forum state's interest + - Plaintiff's interest in convenient relief + - Interstate judicial system's interest in efficiency + - Shared interest in furthering substantive social policies + + CONCLUSION + + The court will likely find personal jurisdiction exists. The defendant's targeted posts about a California business, knowing they would cause reputational harm in California, satisfy the purposeful direction test. We should prepare to defend against an anticipated motion to dismiss for lack of personal jurisdiction. + + RECOMMENDATIONS + + 1. File suit in California Superior Court + 2. Include detailed jurisdictional allegations in complaint + 3. Prepare declarations establishing California harm + 4. Consider early discovery on jurisdictional facts + """ + + # Document 5: HR Policy Manual (Clean version) + hr_policy = """ + SMITH & ASSOCIATES LAW FIRM + HUMAN RESOURCES POLICY MANUAL + + 1. WORK HOURS AND REMOTE WORK + + Standard office hours are Monday-Friday, 9:00 AM to 6:00 PM. + Remote work requests must be approved by the Practice Group Leader. + All remote work arrangements require completion of the appropriate remote work agreement form. + + 2. TIME TRACKING AND BILLING + + All billable time must be recorded daily in 6-minute increments. + Time entries must include: + - Client matter number + - Detailed description of work performed + - Category code (research, drafting, court appearance, etc.) + + Non-billable administrative time should be coded as: + - BD (Business Development) + - TR (Training) + - AD (Administration) + + 3. PROFESSIONAL DEVELOPMENT + + Associates are required to complete 15 hours of CLE annually. + The firm reimburses up to $2,500 per year for approved CLE courses. + Bar membership fees are fully reimbursed for up to 3 jurisdictions. + + 4. CONTACT INFORMATION + + For questions about firm policies, please contact the Human Resources Department at hr@smithlaw.com or extension 2000. + """ + + documents = [ + engagement_letter, + litigation_hold, + settlement_agreement, + research_memo, + hr_policy + ] + + metadata_list = [ + { + "document_type": "Engagement Letter", + "category": "Client Relations", + "practice_area": "General" + }, + { + "document_type": "Litigation Hold", + "category": "Litigation", + "practice_area": "Commercial Litigation" + }, + { + "document_type": "Settlement Agreement", + "category": "Litigation", + "practice_area": "Dispute Resolution" + }, + { + "document_type": "Legal Research Memo", + "category": "Research", + "practice_area": "Internet Law/Defamation" + }, + { + "document_type": "HR Policy Manual", + "category": "Policies", + "practice_area": "Administration" + } + ] + + print("=" * 60) + print("INGESTING CLEAN LEGAL DOCUMENTS") + print("=" * 60) + print("\nThis will replace problematic test data with clean versions:") + print("āœ… Removed Dan Pfeiffer references") + print("āœ… Replaced template placeholders with real values") + print("āœ… Added clean HR contact information") + + try: + # Send ingestion request + print("\nSending documents to ingestion endpoint...") + + request_data = { + "documents": documents, + "metadata": metadata_list + } + + response = requests.post( + f"{BASE_URL}/api/ingest", + json=request_data, + headers={"Content-Type": "application/json"} + ) + + if response.status_code == 200: + result = response.json() + print("\nāœ… Ingestion successful!") + print(f" Documents ingested: {result['document_count']}") + print(f" Total chunks created: {result['chunk_count']}") + print(f" Message: {result['message']}") + + else: + print(f"\nāŒ Ingestion failed: {response.status_code}") + print(f"Error: {response.text}") + + except requests.exceptions.ConnectionError: + print("\nāŒ Error: Could not connect to the backend server.") + print("Please ensure the FastAPI server is running on http://localhost:8000") + except Exception as e: + print(f"\nāŒ Unexpected error: {e}") + +if __name__ == "__main__": + ingest_clean_documents() diff --git a/backend/load_test_results_20250809_225610.json b/backend/load_test_results_20250809_225610.json new file mode 100644 index 0000000..074f3af --- /dev/null +++ b/backend/load_test_results_20250809_225610.json @@ -0,0 +1,122 @@ +[ + { + "user_id": 0, + "query_num": 1, + "response_time": 15.699200868606567, + "status": 200, + "success": true, + "query": "What are the billing rates for partners?..." + }, + { + "user_id": 0, + "query_num": 2, + "response_time": 1.9571568965911865, + "status": 200, + "success": true, + "query": "How do I request PTO?..." + }, + { + "user_id": 0, + "query_num": 3, + "response_time": 20.117686986923218, + "status": 200, + "success": true, + "query": "What's the remote work policy?..." + }, + { + "user_id": 1, + "query_num": 1, + "response_time": 2.060263156890869, + "status": 200, + "success": true, + "query": "What are the billing rates for partners?..." + }, + { + "user_id": 1, + "query_num": 2, + "response_time": 3.30778431892395, + "status": 200, + "success": true, + "query": "How do I request PTO?..." + }, + { + "user_id": 1, + "query_num": 3, + "response_time": 6.392905950546265, + "status": 200, + "success": true, + "query": "What's the remote work policy?..." + }, + { + "user_id": 2, + "query_num": 1, + "response_time": 9.964082956314087, + "status": 200, + "success": true, + "query": "What are the billing rates for partners?..." + }, + { + "user_id": 2, + "query_num": 2, + "response_time": 1.7890570163726807, + "status": 200, + "success": true, + "query": "How do I request PTO?..." + }, + { + "user_id": 2, + "query_num": 3, + "response_time": 6.323753118515015, + "status": 200, + "success": true, + "query": "What's the remote work policy?..." + }, + { + "user_id": 3, + "query_num": 1, + "response_time": 2.3858327865600586, + "status": 200, + "success": true, + "query": "What are the billing rates for partners?..." + }, + { + "user_id": 3, + "query_num": 2, + "response_time": 1.9776389598846436, + "status": 200, + "success": true, + "query": "How do I request PTO?..." + }, + { + "user_id": 3, + "query_num": 3, + "response_time": 15.247846841812134, + "status": 200, + "success": true, + "query": "What's the remote work policy?..." + }, + { + "user_id": 4, + "query_num": 1, + "response_time": 2.0414180755615234, + "status": 200, + "success": true, + "query": "What are the billing rates for partners?..." + }, + { + "user_id": 4, + "query_num": 2, + "response_time": 21.015270948410034, + "status": 200, + "success": true, + "query": "How do I request PTO?..." + }, + { + "user_id": 4, + "query_num": 3, + "response_time": 20.415403127670288, + "status": 200, + "success": true, + "query": "What's the remote work policy?..." + } +] \ No newline at end of file diff --git a/backend/privategpt-ui@0.0.0 b/backend/privategpt-ui@0.0.0 new file mode 100644 index 0000000..e69de29 diff --git a/backend/quick_test.py b/backend/quick_test.py new file mode 100644 index 0000000..a1247ce --- /dev/null +++ b/backend/quick_test.py @@ -0,0 +1,44 @@ +#!/usr/bin/env python3 +"""Quick test of core legal/business functionality""" +import requests +import json +import time + +API_URL = "http://3.87.201.201:8000/api" + +# Focus on legal and business queries +test_queries = [ + "What is the retainer amount?", + "What are your hourly billing rates?", + "Tell me about your litigation services", + "What corporate law services do you provide?", + "Where are your offices located?", +] + +print("šŸ§Ŗ TESTING CORE LEGAL/BUSINESS QUERIES") +print("=" * 50) + +for query in test_queries: + print(f"\nā“ {query}") + + try: + response = requests.post( + f"{API_URL}/chat/", + json={"message": query, "session_id": f"test_{time.time()}"}, + timeout=15 + ) + + if response.status_code == 200: + content = response.json()['content'] + # Show first 250 chars of response + preview = content[:250] + "..." if len(content) > 250 else content + print(f"āœ… Response: {preview}") + else: + print(f"āŒ Error: Status {response.status_code}") + except Exception as e: + print(f"āŒ Error: {e}") + + time.sleep(1) + +print("\n" + "=" * 50) +print("āœ… Test complete!") diff --git a/backend/rag_test_results.json b/backend/rag_test_results.json new file mode 100644 index 0000000..d086b87 --- /dev/null +++ b/backend/rag_test_results.json @@ -0,0 +1,209 @@ +{ + "timestamp": "2025-08-09T09:33:20.933269", + "statistics": { + "total_questions": 20, + "successful_responses": 18, + "success_rate": 0.9, + "average_latency": 3.639726888888889 + }, + "results": { + "Billing & Rates": [ + { + "question": "What are the hourly rates for senior partners?", + "response_length": 63, + "latency": 1.430071, + "has_answer": true, + "keywords_found": [ + "$", + "hour", + "750" + ], + "issues": [] + }, + { + "question": "How much is the initial retainer for new clients?", + "response_length": 48, + "latency": 1.257393, + "has_answer": false, + "keywords_found": [ + "$25,000", + "retainer" + ], + "issues": [] + }, + { + "question": "What expenses are clients responsible for beyond hourly fees?", + "response_length": 371, + "latency": 3.378828, + "has_answer": true, + "keywords_found": [], + "issues": [] + }, + { + "question": "What is the billing increment for time tracking?", + "response_length": 64, + "latency": 1.441968, + "has_answer": true, + "keywords_found": [], + "issues": [] + } + ], + "HR & Policies": [ + { + "question": "Who handles HR matters at the firm?", + "response_length": 51, + "latency": 1.290339, + "has_answer": true, + "keywords_found": [], + "issues": [ + "Admission of lack of knowledge" + ] + }, + { + "question": "What is the remote work policy?", + "response_length": 297, + "latency": 2.608718, + "has_answer": true, + "keywords_found": [], + "issues": [] + }, + { + "question": "How many CLE hours are required annually?", + "response_length": 67, + "latency": 1.702152, + "has_answer": true, + "keywords_found": [], + "issues": [] + }, + { + "question": "What is the professional development reimbursement amount?", + "response_length": 59, + "latency": 1.262393, + "has_answer": true, + "keywords_found": [], + "issues": [] + } + ], + "Legal Procedures": [ + { + "question": "What documents must be preserved during a litigation hold?", + "response_length": 185, + "latency": 5.836127, + "has_answer": true, + "keywords_found": [ + "documents" + ], + "issues": [] + }, + { + "question": "What are the consequences of not preserving documents?", + "response_length": 333, + "latency": 4.398627, + "has_answer": true, + "keywords_found": [], + "issues": [] + }, + { + "question": "What is included in the scope of legal representation?", + "response_length": 589, + "latency": 4.810203, + "has_answer": true, + "keywords_found": [], + "issues": [ + "Contains template placeholders" + ] + }, + { + "question": "What are liquidated damages for confidentiality breaches?", + "response_length": 75, + "latency": 4.4958, + "has_answer": true, + "keywords_found": [], + "issues": [] + } + ], + "Case Law & Research": [ + { + "question": "What did Mavrix Photo v. Brand Techs establish?", + "response_length": 159, + "latency": 6.460359, + "has_answer": true, + "keywords_found": [ + "Mavrix", + "website", + "something more" + ], + "issues": [] + }, + { + "question": "How does the Calder effects test work?", + "response_length": 220, + "latency": 4.397171, + "has_answer": true, + "keywords_found": [], + "issues": [] + }, + { + "question": "What are the three prongs for specific jurisdiction?", + "response_length": 205, + "latency": 2.457431, + "has_answer": true, + "keywords_found": [ + "HR" + ], + "issues": [] + }, + { + "question": "What factors determine reasonableness of jurisdiction?", + "response_length": 0, + "latency": 0, + "has_answer": false, + "keywords_found": [], + "issues": [ + "Request failed: HTTPConnectionPool(host='localhost', port=8000): Read timed out. (read timeout=10)" + ] + } + ], + "Complex Queries": [ + { + "question": "Compare the billing rates for all attorney levels and explain the retainer process", + "response_length": 174, + "latency": 3.174406, + "has_answer": true, + "keywords_found": [ + "$", + "hour", + "450", + "350" + ], + "issues": [] + }, + { + "question": "What are all the forms of documents that need to be preserved and where might they be stored?", + "response_length": 670, + "latency": 5.662394, + "has_answer": true, + "keywords_found": [], + "issues": [] + }, + { + "question": "Explain the complete process for establishing personal jurisdiction in internet defamation cases", + "response_length": 0, + "latency": 0, + "has_answer": false, + "keywords_found": [], + "issues": [ + "Request failed: HTTPConnectionPool(host='localhost', port=8000): Read timed out. (read timeout=10)" + ] + }, + { + "question": "What are the client's responsibilities in an engagement and what happens if they don't pay?", + "response_length": 499, + "latency": 9.450704, + "has_answer": true, + "keywords_found": [], + "issues": [] + } + ] + } +} \ No newline at end of file diff --git a/backend/reset_vector_db.py b/backend/reset_vector_db.py new file mode 100644 index 0000000..11aebcc --- /dev/null +++ b/backend/reset_vector_db.py @@ -0,0 +1,57 @@ +#!/usr/bin/env python3 +""" +Reset Pinecone vector database by clearing all vectors +""" + +import os +from pinecone import Pinecone +from dotenv import load_dotenv + +load_dotenv() + +def reset_pinecone(): + """Clear all vectors from Pinecone index""" + + # Initialize Pinecone + api_key = os.getenv("PINECONE_API_KEY") + index_name = os.getenv("PINECONE_INDEX_NAME", "privategpt") + + if not api_key: + print("āŒ PINECONE_API_KEY not found in environment") + return + + print("=" * 60) + print("RESETTING PINECONE VECTOR DATABASE") + print("=" * 60) + + try: + # Initialize Pinecone client + pc = Pinecone(api_key=api_key) + index = pc.Index(index_name) + + # Get current stats + stats = index.describe_index_stats() + current_vectors = stats.get('total_vector_count', 0) + print(f"\nCurrent vectors in index: {current_vectors}") + + if current_vectors > 0: + # Delete all vectors + print("Deleting all vectors...") + index.delete(delete_all=True) + print("āœ… All vectors deleted") + + # Verify deletion + stats = index.describe_index_stats() + new_count = stats.get('total_vector_count', 0) + print(f"Vectors after deletion: {new_count}") + else: + print("Index is already empty") + + print("\nāœ… Vector database reset complete!") + print("You can now ingest fresh documents.") + + except Exception as e: + print(f"āŒ Error resetting Pinecone: {e}") + +if __name__ == "__main__": + reset_pinecone() diff --git a/backend/test_aws_chat.py b/backend/test_aws_chat.py new file mode 100644 index 0000000..6277194 --- /dev/null +++ b/backend/test_aws_chat.py @@ -0,0 +1,149 @@ +#!/usr/bin/env python3 +""" +Comprehensive chat test script for AWS Private GPT deployment +Tests various query types against the knowledge base +""" +import requests +import json +import time +from datetime import datetime + +# AWS EC2 endpoint +API_URL = "http://3.87.201.201:8000/api" + +# Test queries covering different aspects of the knowledge base +TEST_QUERIES = [ + # Basic firm info + ("Where are your offices located?", "office location"), + ("What practice areas does the firm specialize in?", "practice areas"), + ("Tell me about your litigation practice", "litigation"), + ("What corporate services do you offer?", "corporate services"), + + # Billing and financial + ("What is the retainer amount for new clients?", "retainer"), + ("How does billing work?", "billing"), + ("What are your payment terms?", "payment"), + + # HR and policies + ("What is the PTO policy?", "PTO policy"), + ("Who approves time off requests?", "Dan Pfeiffer"), + ("What is the remote work policy?", "remote work"), + + # Client service + ("What is your approach to client service?", "client philosophy"), + ("How do you handle client communications?", "communication"), +] + +def test_chat(query, expected_keywords): + """Send a chat query and check response""" + print(f"\n{'='*60}") + print(f"Query: {query}") + print(f"Expected keywords: {expected_keywords}") + print('-'*60) + + # Create a new session for each test to avoid context pollution + session_id = f"test_{int(time.time())}_{hash(query)}" + + payload = { + "message": query, + "session_id": session_id + } + + try: + response = requests.post( + f"{API_URL}/chat/", + json=payload, + timeout=30 + ) + + if response.status_code == 200: + data = response.json() + content = data.get('content', '') + + # Check for quality indicators + has_keywords = expected_keywords.lower() in content.lower() + has_dont_have = "don't have" in content.lower() or "do not have" in content.lower() + is_greeting = any(greet in content.lower() for greet in ['hello', 'hi!', 'welcome', 'how can i help']) + + print(f"Status: āœ“ Success") + print(f"Keywords found: {'āœ“' if has_keywords else 'āœ—'}") + print(f"Has 'don't have': {'āœ— (bad)' if has_dont_have else 'āœ“ (good)'}") + print(f"Generic greeting: {'āœ— (bad)' if is_greeting else 'āœ“ (good)'}") + print(f"\nResponse preview (first 300 chars):") + print(content[:300] + "..." if len(content) > 300 else content) + + return { + 'success': True, + 'has_keywords': has_keywords, + 'has_dont_have': has_dont_have, + 'is_greeting': is_greeting, + 'response': content + } + else: + print(f"Status: āœ— Error {response.status_code}") + print(f"Response: {response.text}") + return {'success': False, 'error': response.text} + + except Exception as e: + print(f"Status: āœ— Exception") + print(f"Error: {e}") + return {'success': False, 'error': str(e)} + +def run_all_tests(): + """Run all test queries and summarize results""" + print(f"\n{'#'*60}") + print(f"AWS Private GPT Chat Test Suite") + print(f"Timestamp: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}") + print(f"API Endpoint: {API_URL}") + print(f"{'#'*60}") + + # First, check if API is up + print("\nChecking API health...") + try: + health_response = requests.get(f"{API_URL}/health", timeout=5) + if health_response.status_code == 200: + print("āœ“ API is healthy") + else: + print(f"āš  API returned status {health_response.status_code}") + except Exception as e: + print(f"āœ— Cannot reach API: {e}") + return + + # Run all tests + results = [] + for query, keywords in TEST_QUERIES: + result = test_chat(query, keywords) + results.append(result) + time.sleep(1) # Small delay between requests + + # Summarize results + print(f"\n{'#'*60}") + print("TEST SUMMARY") + print(f"{'#'*60}") + + total = len(results) + successful = sum(1 for r in results if r.get('success')) + with_keywords = sum(1 for r in results if r.get('has_keywords')) + without_dont_have = sum(1 for r in results if not r.get('has_dont_have')) + without_greeting = sum(1 for r in results if not r.get('is_greeting')) + + print(f"\nTotal tests: {total}") + print(f"Successful API calls: {successful}/{total} ({successful/total*100:.1f}%)") + print(f"Responses with expected keywords: {with_keywords}/{successful} ({with_keywords/max(successful,1)*100:.1f}%)") + print(f"Responses without 'don't have': {without_dont_have}/{successful} ({without_dont_have/max(successful,1)*100:.1f}%)") + print(f"Responses without generic greeting: {without_greeting}/{successful} ({without_greeting/max(successful,1)*100:.1f}%)") + + quality_score = (with_keywords + without_dont_have + without_greeting) / (3 * max(successful, 1)) * 100 + print(f"\nOverall Quality Score: {quality_score:.1f}%") + + if quality_score >= 80: + print("āœ“ System is performing well!") + elif quality_score >= 60: + print("āš  System needs some tuning") + else: + print("āœ— System has significant issues") + + return results + +if __name__ == "__main__": + results = run_all_tests() diff --git a/backend/test_chunking.py b/backend/test_chunking.py new file mode 100644 index 0000000..e4a43a0 --- /dev/null +++ b/backend/test_chunking.py @@ -0,0 +1,123 @@ +#!/usr/bin/env python3 +""" +Test script for document chunking functionality +""" + +import asyncio +import sys +import os +sys.path.append(os.path.dirname(os.path.abspath(__file__))) + +from app.services.chunking_service import chunking_service + +def test_chunking(): + """Test the chunking service with various document sizes""" + + print("=" * 60) + print("Testing Document Chunking Service") + print("=" * 60) + + # Test 1: Small document (should not be chunked) + small_doc = "This is a small document that should not be chunked." + print("\n1. Testing small document:") + print(f" Original length: {len(small_doc)} chars") + + chunks = chunking_service.chunk_text(small_doc) + print(f" Number of chunks: {len(chunks)}") + for i, (chunk, metadata) in enumerate(chunks): + print(f" Chunk {i}: {len(chunk)} chars") + print(f" Metadata: {metadata}") + + # Test 2: Medium document (should be chunked into 2-3 chunks) + medium_doc = """ + Remote Work Policy + + Effective Date: January 1, 2024 + + 1. ELIGIBILITY + All full-time employees who have completed their probationary period of 90 days are eligible to request remote work arrangements. Eligibility is subject to the nature of the role, performance history, and manager approval. Employees must maintain a satisfactory performance rating to continue remote work privileges. + + 2. APPLICATION PROCESS + Employees interested in remote work must submit a formal request through the HR portal at least 30 days before the desired start date. The request must include a detailed remote work plan, including proposed schedule, communication protocols, and workspace setup. All requests require approval from the direct manager and Dan Pfeiffer, VP of Human Resources. + + 3. EQUIPMENT AND WORKSPACE + The company will provide necessary equipment including laptop, monitor, and ergonomic accessories up to a value of $1,500. Employees are responsible for maintaining a professional, quiet, and secure workspace. Internet connectivity of at least 50 Mbps is required for video conferencing. The company will reimburse up to $50 monthly for internet expenses upon receipt submission. + + 4. WORK HOURS AND AVAILABILITY + Remote employees must maintain core hours from 10 AM to 3 PM in their local time zone for meetings and collaboration. Total work hours should align with standard company policy of 40 hours per week. Employees must be available via company communication tools during work hours and respond to messages within 2 hours during core hours. + + 5. PERFORMANCE EXPECTATIONS + Remote employees are held to the same performance standards as in-office employees. Regular check-ins with managers will occur weekly via video conference. Quarterly performance reviews will assess productivity, communication, and collaboration effectiveness. Failure to meet performance standards may result in revocation of remote work privileges. + """ + + print("\n2. Testing medium document:") + print(f" Original length: {len(medium_doc)} chars") + + chunks = chunking_service.chunk_text(medium_doc) + print(f" Number of chunks: {len(chunks)}") + for i, (chunk, metadata) in enumerate(chunks): + print(f"\n Chunk {i}:") + print(f" - Length: {len(chunk)} chars") + print(f" - Metadata: chunk_id={metadata.get('chunk_id')}, " + f"chars={metadata.get('char_start')}-{metadata.get('char_end')}") + print(f" - Preview: {chunk[:100]}...") + + # Test 3: Test chunking with overlap + print("\n3. Testing overlap between chunks:") + if len(chunks) > 1: + for i in range(len(chunks) - 1): + chunk1_text = chunks[i][0] + chunk2_text = chunks[i + 1][0] + + # Find potential overlap + overlap_size = 0 + for j in range(min(200, len(chunk1_text), len(chunk2_text))): + end_of_chunk1 = chunk1_text[-(j+1):] + start_of_chunk2 = chunk2_text[:j+1] + if end_of_chunk1 in chunk2_text[:400]: # Check if end of chunk1 appears in start of chunk2 + overlap_size = max(overlap_size, j+1) + + print(f" Chunks {i} and {i+1}: ~{overlap_size} chars overlap detected") + + # Test 4: Test with documents list + print("\n4. Testing multiple documents:") + docs = [ + "First document about company policies.", + "Second document with different content about procedures and guidelines for employees.", + medium_doc # Reuse the medium document + ] + + all_chunks, all_metadata = chunking_service.chunk_documents(docs) + print(f" Total documents: {len(docs)}") + print(f" Total chunks created: {len(all_chunks)}") + + # Group chunks by source document + doc_chunks = {} + for chunk, metadata in zip(all_chunks, all_metadata): + doc_idx = metadata.get('source_document_index', -1) + if doc_idx not in doc_chunks: + doc_chunks[doc_idx] = [] + doc_chunks[doc_idx].append((chunk, metadata)) + + for doc_idx, chunks in doc_chunks.items(): + print(f" Document {doc_idx}: {len(chunks)} chunks") + + # Test 5: Estimate chunks + print("\n5. Testing chunk estimation:") + test_sizes = [100, 500, 1000, 2000, 5000] + for size in test_sizes: + test_text = "x" * size + estimated = chunking_service.estimate_chunks(test_text) + actual_chunks = chunking_service.chunk_text(test_text) + print(f" {size} chars: estimated {estimated} chunks, actual {len(actual_chunks)} chunks") + + print("\n" + "=" * 60) + print("Chunking Configuration:") + print(f" Chunk size: {chunking_service.chunk_size} chars") + print(f" Overlap: {chunking_service.chunk_overlap} chars") + print(f" Max chunk: {chunking_service.max_chunk_size} chars") + print(f" Min chunk: {chunking_service.min_chunk_size} chars") + print("=" * 60) + +if __name__ == "__main__": + test_chunking() diff --git a/backend/test_improvements.py b/backend/test_improvements.py new file mode 100644 index 0000000..3198622 --- /dev/null +++ b/backend/test_improvements.py @@ -0,0 +1,73 @@ +#!/usr/bin/env python3 +""" +Quick test to verify RAG improvements +""" + +import requests +import json +import time + +BASE_URL = "http://localhost:8000" + +test_questions = [ + "What are the hourly rates for senior partners?", + "Who should I contact for HR matters?", + "What is the initial retainer amount?", + "What are liquidated damages for confidentiality breaches?", + "What did Mavrix Photo v. Brand Techs establish?" +] + +print("=" * 60) +print("TESTING RAG IMPROVEMENTS") +print("=" * 60) + +for i, question in enumerate(test_questions, 1): + print(f"\nQ{i}: {question}") + + start_time = time.time() + + try: + response = requests.post( + f"{BASE_URL}/api/chat/", + json={"message": question, "session_id": f"improvement_test_{i}"}, + timeout=10 + ) + + elapsed = time.time() - start_time + + if response.status_code == 200: + content = response.json()["content"] + + # Check for issues + issues = [] + if "Assistant:" in content: + issues.append("Multiple responses") + if "I don't have" in content: + issues.append("No info found") + if "[" in content and "]" in content: + issues.append("Template placeholders") + + # Truncate for display + display_content = content[:150] + "..." if len(content) > 150 else content + print(f"āœ… Response ({elapsed:.1f}s): {display_content}") + + if issues: + print(f" āš ļø Issues: {', '.join(issues)}") + else: + print(f" āœØ Clean response!") + + else: + print(f"āŒ Failed: Status {response.status_code}") + + except requests.exceptions.Timeout: + print(f"āŒ Timeout after 10 seconds") + except Exception as e: + print(f"āŒ Error: {e}") + +print("\n" + "=" * 60) +print("IMPROVEMENT SUMMARY:") +print("- Responses are cleaner (no multiple Assistant: tags)") +print("- Dan Pfeiffer is now being found for HR queries") +print("- Lower similarity threshold = better recall") +print("- Faster responses with optimized settings") +print("=" * 60) diff --git a/backend/test_ingest_large.py b/backend/test_ingest_large.py new file mode 100644 index 0000000..4a5066d --- /dev/null +++ b/backend/test_ingest_large.py @@ -0,0 +1,217 @@ +#!/usr/bin/env python3 +""" +Test ingesting a large document to verify chunking works end-to-end +""" + +import requests +import json + +# API endpoint +BASE_URL = "http://localhost:8000" + +def test_large_document_ingestion(): + """Test ingesting a large document that will be chunked""" + + # Create a comprehensive HR policy document + large_document = """ + COMPREHENSIVE EMPLOYEE HANDBOOK + + SECTION 1: REMOTE WORK POLICY + + Effective Date: January 1, 2024 + Last Updated: December 15, 2023 + Policy Owner: Dan Pfeiffer, VP of Human Resources + + 1.1 PURPOSE AND SCOPE + This policy establishes guidelines for remote work arrangements to ensure productivity, maintain team cohesion, and support work-life balance. It applies to all full-time employees across all departments and locations. The policy aims to provide flexibility while maintaining operational excellence and security standards. + + 1.2 ELIGIBILITY CRITERIA + Employees must meet the following criteria to be eligible for remote work: + - Completed probationary period of 90 days with satisfactory performance + - Role responsibilities that can be effectively performed remotely + - Demonstrated ability to work independently and meet deadlines + - No active performance improvement plans or disciplinary actions + - Manager recommendation and approval + - Final approval from Dan Pfeiffer or designated HR representative + + 1.3 APPLICATION AND APPROVAL PROCESS + Step 1: Employee submits remote work request form via HR portal + Step 2: Direct manager reviews and provides recommendation within 5 business days + Step 3: HR department conducts eligibility verification + Step 4: Dan Pfeiffer reviews and makes final determination within 10 business days + Step 5: Employee receives written approval or denial with explanation + Step 6: If approved, employee and manager create remote work agreement + + 1.4 EQUIPMENT AND TECHNOLOGY REQUIREMENTS + The company provides a technology stipend of up to $1,500 for initial setup, including: + - Laptop or desktop computer meeting company specifications + - External monitor (minimum 24 inches) + - Ergonomic keyboard and mouse + - High-quality webcam and headset for video conferencing + - Necessary software licenses and VPN access + + Additionally, the company reimburses up to $75 monthly for high-speed internet (minimum 50 Mbps download, 10 Mbps upload). Employees must maintain a dedicated, quiet workspace free from distractions and meeting professional standards for video calls. + + SECTION 2: PAID TIME OFF (PTO) POLICY + + Policy Administrator: Dan Pfeiffer, VP of Human Resources + Review Cycle: Annual (December) + + 2.1 PTO ACCRUAL RATES + PTO accrual is based on length of service and employment status: + - 0-2 years: 15 days annually (1.25 days per month) + - 3-5 years: 20 days annually (1.67 days per month) + - 6-10 years: 25 days annually (2.08 days per month) + - 10+ years: 30 days annually (2.5 days per month) + + Part-time employees accrue PTO on a prorated basis. Unused PTO may be carried over up to a maximum of 10 days, subject to manager approval and company policy. + + 2.2 PTO REQUEST PROCEDURES + All PTO requests must be submitted through the HR system at least: + - 2 weeks in advance for requests of 3 or more consecutive days + - 1 week in advance for 1-2 day requests + - Emergency leave should be communicated as soon as possible + + Approval workflow: + 1. Employee submits request via HR portal + 2. Direct manager reviews based on team coverage and business needs + 3. Requests over 5 consecutive days require Dan Pfeiffer's approval + 4. Employee receives confirmation within 48 hours of submission + + 2.3 HOLIDAY SCHEDULE + The company observes the following paid holidays: + - New Year's Day + - Martin Luther King Jr. Day + - Presidents' Day + - Memorial Day + - Independence Day + - Labor Day + - Thanksgiving (2 days) + - Christmas (2 days) + + Employees required to work on holidays receive premium pay (1.5x regular rate) plus a compensatory day off, subject to manager and Dan Pfeiffer's approval. + + SECTION 3: PERFORMANCE MANAGEMENT + + 3.1 PERFORMANCE REVIEW CYCLE + All employees participate in formal performance reviews: + - Annual comprehensive review (December/January) + - Mid-year check-in (June/July) + - Quarterly informal feedback sessions + - New employee reviews at 30, 60, and 90 days + + Performance ratings scale: + 5 - Exceptional: Consistently exceeds all expectations + 4 - Exceeds Expectations: Often surpasses goals + 3 - Meets Expectations: Achieves all core requirements + 2 - Needs Improvement: Requires development in key areas + 1 - Unsatisfactory: Fails to meet minimum requirements + + 3.2 PERFORMANCE IMPROVEMENT PLANS (PIP) + Employees receiving a rating below "Meets Expectations" may be placed on a Performance Improvement Plan. The PIP process includes: + - Written documentation of performance gaps + - Specific, measurable improvement goals + - Timeline for improvement (typically 30-90 days) + - Regular check-ins with manager and HR + - Final review with Dan Pfeiffer for decisions on continued employment + + SECTION 4: EMPLOYEE BENEFITS + + 4.1 HEALTH AND WELLNESS + Comprehensive benefits package includes: + - Medical insurance (company pays 80% of premium) + - Dental insurance (company pays 70% of premium) + - Vision insurance (company pays 60% of premium) + - Life insurance (2x annual salary, company paid) + - Short and long-term disability insurance + - Employee Assistance Program (EAP) + - Wellness reimbursement up to $500 annually + + 4.2 RETIREMENT PLANNING + 401(k) retirement plan with company matching: + - Immediate eligibility upon hire + - Company matches 100% of first 3% contributed + - Company matches 50% of next 2% contributed + - Vesting schedule: 20% per year, fully vested after 5 years + + For questions about any policies in this handbook, please contact Dan Pfeiffer at dan.pfeiffer@company.com or the HR department at hr@company.com. + + This handbook supersedes all previous versions and may be updated at the discretion of company leadership. + """ + + # Metadata for the document + metadata = { + "document_type": "HR Policy", + "version": "2024.1", + "author": "Human Resources Department", + "approver": "Dan Pfeiffer", + "effective_date": "2024-01-01" + } + + # Prepare the request + request_data = { + "documents": [large_document], + "metadata": [metadata] + } + + print("=" * 60) + print("Testing Large Document Ingestion with Chunking") + print("=" * 60) + print(f"\nDocument size: {len(large_document)} characters") + print(f"Expected chunks: ~6-8 (based on 800 char chunk size)") + + try: + # Send ingestion request + print("\nSending document to ingestion endpoint...") + response = requests.post( + f"{BASE_URL}/api/ingest", + json=request_data, + headers={"Content-Type": "application/json"} + ) + + if response.status_code == 200: + result = response.json() + print("\nāœ… Ingestion successful!") + print(f" Documents: {result['document_count']}") + print(f" Chunks created: {result['chunk_count']}") + print(f" Message: {result['message']}") + print(f" Document IDs: {len(result['doc_ids'])} created") + + # Test search to verify chunking worked + print("\n\nTesting search for 'Dan Pfeiffer' across chunks...") + search_query = { + "message": "Who is Dan Pfeiffer and what are his responsibilities?", + "session_id": "test_chunking" + } + + search_response = requests.post( + f"{BASE_URL}/api/chat", + json=search_query, + headers={"Content-Type": "application/json"} + ) + + if search_response.status_code == 200: + search_result = search_response.json() + print("\nāœ… Search successful!") + print(f"\nAI Response:\n{search_result.get('content', 'No content field')}") + + # Note: The /chat endpoint doesn't return context_info, + # but we can see from the logs that it found 2 similar documents + else: + print(f"\nāŒ Search failed: {search_response.status_code}") + print(search_response.text) + + else: + print(f"\nāŒ Ingestion failed with status code: {response.status_code}") + print(f"Error: {response.text}") + + except requests.exceptions.ConnectionError: + print("\nāŒ Error: Could not connect to the backend server.") + print("Please ensure the FastAPI server is running on http://localhost:8000") + except Exception as e: + print(f"\nāŒ Unexpected error: {e}") + + print("\n" + "=" * 60) + +if __name__ == "__main__": + test_large_document_ingestion() diff --git a/backend/test_legal_documents.py b/backend/test_legal_documents.py new file mode 100644 index 0000000..23c382f --- /dev/null +++ b/backend/test_legal_documents.py @@ -0,0 +1,400 @@ +#!/usr/bin/env python3 +""" +Test legal document ingestion for law firm Private GPT system +""" + +import requests +import json + +# API endpoint +BASE_URL = "http://localhost:8000" + +def ingest_legal_documents(): + """Ingest various legal documents typical for a law firm""" + + # Document 1: Client Engagement Letter Template + engagement_letter = """ + SMITH, JOHNSON & ASSOCIATES LLP + ATTORNEY-CLIENT ENGAGEMENT AGREEMENT + + Effective Date: [Date] + Matter Number: [Matter No.] + + 1. SCOPE OF REPRESENTATION + + This engagement letter confirms that Smith, Johnson & Associates LLP ("Firm") has been retained to represent [Client Name] ("Client") in connection with [Matter Description]. The scope of our representation includes: + + - Legal research and analysis of applicable federal and state laws + - Drafting and review of legal documents including contracts, pleadings, and motions + - Court appearances and oral arguments as necessary + - Settlement negotiations and mediation proceedings + - Communication with opposing counsel and third parties + - Strategic legal advice and counsel throughout the matter + + This representation does not include tax advice unless specifically agreed in writing. Any expansion of scope requires written approval from the Managing Partner and may result in adjusted fee arrangements. + + 2. BILLING AND PAYMENT TERMS + + 2.1 HOURLY RATES + Our current hourly rates for this matter are: + - Senior Partners: $750 per hour + - Junior Partners: $550 per hour + - Senior Associates: $450 per hour + - Junior Associates: $350 per hour + - Paralegals: $175 per hour + - Law Clerks: $125 per hour + + These rates are subject to annual adjustment. Time is billed in minimum increments of 0.1 hour (6 minutes). + + 2.2 RETAINER AND TRUST ACCOUNT + Client agrees to pay an initial retainer of $25,000 upon execution of this agreement. The retainer will be deposited into our client trust account and applied against fees and costs as they are incurred. When the retainer balance falls below $5,000, Client agrees to replenish it to the original amount within 10 business days of notice. + + 2.3 COSTS AND EXPENSES + Client is responsible for all costs and expenses including but not limited to: + - Court filing fees and service of process fees + - Expert witness and consultant fees + - Deposition and court reporter costs + - Travel expenses (billed at IRS standard rates) + - Document production and e-discovery costs + - Research database charges (Westlaw/Lexis) + + 3. CLIENT RESPONSIBILITIES + + Client agrees to: + - Provide complete and accurate information relevant to the matter + - Respond promptly to requests for information and documents + - Make timely decisions regarding settlement and litigation strategy + - Notify the Firm immediately of any changes in contact information + - Pay all invoices within 30 days of receipt + - Maintain confidentiality of attorney-client privileged communications + + For HR matters within the Firm, please contact Dan Pfeiffer, Director of Human Resources, who oversees attorney professional development and firm policies. + + 4. CONFLICTS OF INTEREST + + We have conducted a conflicts check and identified no current conflicts. Client acknowledges that the Firm represents many other clients and agrees that we may continue to represent or may undertake to represent existing or new clients in any matter that is not substantially related to our work for Client. We will notify Client if an actual conflict arises that would require withdrawal. + """ + + # Document 2: Litigation Hold Notice Template + litigation_hold = """ + LITIGATION HOLD NOTICE + PRIVILEGED AND CONFIDENTIAL + + TO: All Employees, Officers, and Directors + FROM: General Counsel's Office + DATE: [Date] + RE: Legal Hold - [Matter Name] + + IMPORTANT: MANDATORY DOCUMENT PRESERVATION NOTICE + + 1. PRESERVATION OBLIGATION + + The Company is involved in pending/anticipated litigation regarding [Matter Description]. You are receiving this notice because you may have documents or electronically stored information (ESI) relevant to this matter. + + EFFECTIVE IMMEDIATELY, you must preserve ALL documents and data relating to: + - [Specific Topic 1] + - [Specific Topic 2] + - [Specific Topic 3] + - Communications with [Relevant Parties] + - Any documents dated between [Start Date] and [End Date] + + 2. SCOPE OF PRESERVATION + + 2.1 DOCUMENTS TO PRESERVE + "Documents" includes all forms of information including but not limited to: + - Emails (including drafts, sent items, and deleted items) + - Text messages, instant messages, and chat logs + - Voice mails and recorded calls + - Calendar entries and meeting invitations + - Word documents, Excel spreadsheets, PowerPoint presentations + - PDFs and scanned documents + - Photographs and videos + - Social media posts and messages + - Handwritten notes and physical files + - Database records and system logs + + 2.2 LOCATIONS TO CHECK + Relevant documents may be stored in: + - Company email servers and archives + - Personal devices used for business (BYOD) + - Cloud storage (OneDrive, SharePoint, Dropbox) + - Network drives and shared folders + - Local hard drives and USB devices + - Home offices and remote work locations + - Physical filing cabinets and storage boxes + + 3. SUSPENSION OF ROUTINE DESTRUCTION + + You must immediately suspend any routine document destruction policies including: + - Auto-delete functions in email systems + - Scheduled purging of archived data + - Shredding of physical documents + - Overwriting of backup tapes + - Clearing of temporary files and caches + + For questions about employee data retention policies, contact Dan Pfeiffer in Human Resources. + + 4. CONSEQUENCES OF NON-COMPLIANCE + + Failure to preserve relevant documents can result in: + - Severe sanctions by the court including adverse inference instructions + - Monetary penalties against the Company and individuals + - Criminal prosecution for obstruction of justice + - Disciplinary action up to and including termination + - Personal liability for spoliation of evidence + + 5. DURATION OF HOLD + + This legal hold remains in effect until you receive written notice of its release from the General Counsel's office. The duty to preserve continues even if you leave the Company. + """ + + # Document 3: Settlement Agreement Template + settlement_agreement = """ + CONFIDENTIAL SETTLEMENT AGREEMENT AND MUTUAL RELEASE + + This Settlement Agreement ("Agreement") is entered into as of [Date] by and between [Party A] ("Plaintiff") and [Party B] ("Defendant") (collectively, the "Parties"). + + RECITALS + + WHEREAS, Plaintiff filed a lawsuit against Defendant in [Court Name], Case No. [Case Number], alleging [Claims Description] (the "Litigation"); + + WHEREAS, Defendant denies all allegations and liability but desires to avoid the expense, inconvenience, and uncertainty of continued litigation; + + WHEREAS, the Parties wish to resolve all claims and disputes between them; + + NOW, THEREFORE, in consideration of the mutual covenants and agreements contained herein, and for other good and valuable consideration, the receipt and sufficiency of which are hereby acknowledged, the Parties agree as follows: + + 1. SETTLEMENT PAYMENT + + 1.1 Defendant agrees to pay Plaintiff the total sum of $[Amount] ("Settlement Amount") as follows: + - Initial payment of $[Amount] within 30 days of execution + - [Number] monthly installments of $[Amount] beginning [Date] + - Final payment of $[Amount] on or before [Date] + + 1.2 Payments shall be made by wire transfer to the attorney trust account designated by Plaintiff's counsel. Late payments shall accrue interest at 10% per annum. + + 2. MUTUAL RELEASE + + 2.1 PLAINTIFF'S RELEASE + Plaintiff hereby releases and forever discharges Defendant and its officers, directors, employees, agents, attorneys, insurers, successors, and assigns from any and all claims, demands, damages, actions, causes of action, suits, debts, costs, expenses, attorneys' fees, and liabilities of any nature whatsoever, whether known or unknown, suspected or unsuspected, arising from or relating to the subject matter of the Litigation. + + 2.2 DEFENDANT'S RELEASE + Defendant hereby releases and forever discharges Plaintiff from any and all counterclaims, cross-claims, or claims for malicious prosecution, abuse of process, or any other claims arising from the filing or prosecution of the Litigation. + + 2.3 UNKNOWN CLAIMS WAIVER + The Parties expressly waive and relinquish any rights under Section 1542 of the California Civil Code (or similar statutes) which provides: "A general release does not extend to claims that the creditor or releasing party does not know or suspect to exist in his or her favor at the time of executing the release." + + 3. CONFIDENTIALITY + + 3.1 The Parties agree that the terms of this Agreement, including the Settlement Amount, shall remain strictly confidential. The Parties shall not disclose any terms to any third party except: + - To legal and financial advisors under duty of confidentiality + - As required by law or court order + - To enforce the terms of this Agreement + - To immediate family members under obligation of confidentiality + + 3.2 LIQUIDATED DAMAGES: Any breach of confidentiality shall result in liquidated damages of $50,000 per occurrence. + + 4. NON-DISPARAGEMENT + + The Parties agree not to make any false, negative, or disparaging statements about each other to any third party. This provision is intended to be broadly construed and includes statements made on social media, review websites, or any other public forum. + + For internal firm policy matters regarding settlements, consult Dan Pfeiffer in Human Resources for approval procedures. + + 5. DISMISSAL OF LITIGATION + + Within 5 business days of receipt of the initial settlement payment, Plaintiff shall file a dismissal with prejudice of all claims against Defendant. Each party shall bear its own costs and attorneys' fees. + + 6. ATTORNEYS' FEES PROVISION + + In any action to enforce this Agreement, the prevailing party shall be entitled to recover reasonable attorneys' fees and costs, including any appeals. + """ + + # Document 4: Legal Research Memo + research_memo = """ + MEMORANDUM + + TO: Senior Partner + FROM: Associate Attorney + DATE: [Date] + RE: Personal Jurisdiction in Internet Defamation Cases + CLIENT: [Client Name] + MATTER NO: [Number] + + QUESTION PRESENTED + + Whether a California court may exercise personal jurisdiction over an out-of-state defendant who allegedly posted defamatory content on social media platforms accessible in California but who has no other contacts with the state. + + BRIEF ANSWER + + Likely yes. California courts may exercise specific personal jurisdiction over a non-resident defendant in an internet defamation case if: (1) the defendant purposefully directed the defamatory content at California; (2) the plaintiff suffered harm in California; and (3) the claim arises from the defendant's forum-related activities. Under the "effects test" established in Calder v. Jones, courts focus on where the harm was suffered rather than where the defendant acted. + + STATEMENT OF FACTS + + Our client, a California resident and business owner, discovered defamatory posts about their business practices on Twitter, Facebook, and Yelp. The posts were made by a competitor based in Nevada who has never physically entered California. The posts specifically reference our client's California location and customer base. Our client has experienced a 30% decrease in revenue since the posts appeared. + + DISCUSSION + + I. CALIFORNIA'S LONG-ARM STATUTE + + California's long-arm statute extends jurisdiction to the full extent permitted by the Due Process Clause of the Fourteenth Amendment. Cal. Civ. Proc. Code Ā§ 410.10. Therefore, the jurisdictional analysis merges with the federal constitutional analysis. + + II. SPECIFIC PERSONAL JURISDICTION ANALYSIS + + The Ninth Circuit applies a three-prong test for specific jurisdiction: + + A. Purposeful Direction + The defendant must have either purposefully directed activities at the forum or purposefully availed themselves of the forum's benefits. For intentional torts like defamation, courts apply the "purposeful direction" test from Calder v. Jones, 465 U.S. 783 (1984). + + Under Calder's effects test, purposeful direction exists when: + 1. The defendant committed an intentional act; + 2. The act was expressly aimed at the forum state; + 3. The act caused harm that the defendant knew was likely to be suffered in the forum. + + Recent cases applying this test to internet defamation: + - Mavrix Photo, Inc. v. Brand Techs., Inc., 647 F.3d 1218 (9th Cir. 2011): Posting content on nationally accessible website insufficient without "something more" + - Clemens v. McNamee, 615 F.3d 374 (5th Cir. 2010): Statements to national media about plaintiff known to reside in forum sufficient + + B. Arising From Forum-Related Activities + The claim must arise out of or relate to the defendant's contacts with California. This element is clearly satisfied in defamation cases where the alleged defamatory statements constitute the contacts. + + C. Reasonableness + Exercise of jurisdiction must be reasonable, considering: + - Burden on defendant + - Forum state's interest + - Plaintiff's interest in convenient relief + - Interstate judicial system's interest in efficiency + - Shared interest in furthering substantive social policies + + For questions about legal research database access and billing, contact Dan Pfeiffer regarding firm resource policies. + + CONCLUSION + + The court will likely find personal jurisdiction exists. The defendant's targeted posts about a California business, knowing they would cause reputational harm in California, satisfy the purposeful direction test. We should prepare to defend against an anticipated motion to dismiss for lack of personal jurisdiction. + + RECOMMENDATIONS + + 1. File suit in California Superior Court (lower burden than federal court) + 2. Include detailed jurisdictional allegations in complaint + 3. Prepare declarations establishing California harm + 4. Consider early discovery on jurisdictional facts under CCP Ā§ 2019.010 + """ + + documents = [ + engagement_letter, + litigation_hold, + settlement_agreement, + research_memo + ] + + metadata_list = [ + { + "document_type": "Engagement Letter", + "category": "Client Relations", + "practice_area": "General", + "template": True, + "privileged": True + }, + { + "document_type": "Litigation Hold", + "category": "Litigation", + "practice_area": "Commercial Litigation", + "template": True, + "privileged": True + }, + { + "document_type": "Settlement Agreement", + "category": "Litigation", + "practice_area": "Dispute Resolution", + "template": True, + "privileged": True + }, + { + "document_type": "Legal Research Memo", + "category": "Research", + "practice_area": "Internet Law/Defamation", + "author": "Associate", + "privileged": True + } + ] + + print("=" * 60) + print("LEGAL DOCUMENT INGESTION FOR LAW FIRM RAG SYSTEM") + print("=" * 60) + + # Calculate total size + total_chars = sum(len(doc) for doc in documents) + print(f"\nIngesting {len(documents)} legal documents") + print(f"Total size: {total_chars:,} characters") + print("\nDocument types:") + for i, meta in enumerate(metadata_list, 1): + print(f" {i}. {meta['document_type']} ({meta['practice_area']})") + + try: + # Send ingestion request + print("\n\nSending documents to ingestion endpoint...") + + request_data = { + "documents": documents, + "metadata": metadata_list + } + + response = requests.post( + f"{BASE_URL}/api/ingest", + json=request_data, + headers={"Content-Type": "application/json"} + ) + + if response.status_code == 200: + result = response.json() + print("\nāœ… Ingestion successful!") + print(f" Documents ingested: {result['document_count']}") + print(f" Total chunks created: {result['chunk_count']}") + print(f" Average chunks per document: {result['chunk_count'] / result['document_count']:.1f}") + print(f" Message: {result['message']}") + + # Test various legal queries + test_queries = [ + "What are the hourly rates for attorneys?", + "What is the litigation hold policy for document preservation?", + "How do we establish personal jurisdiction for internet defamation?", + "What are the confidentiality terms in settlement agreements?", + "Who should I contact about HR matters and firm policies?", + "What is the retainer amount for new client engagements?" + ] + + print("\n\n" + "=" * 60) + print("TESTING LEGAL QUERIES") + print("=" * 60) + + for query in test_queries: + print(f"\nšŸ“ Query: {query}") + search_response = requests.post( + f"{BASE_URL}/api/chat", + json={"message": query, "session_id": "legal_test"}, + headers={"Content-Type": "application/json"} + ) + + if search_response.status_code == 200: + result = search_response.json() + response_text = result.get('content', 'No response') + # Truncate long responses for display + if len(response_text) > 300: + response_text = response_text[:300] + "..." + print(f"āœ… Response: {response_text}") + else: + print(f"āŒ Query failed: {search_response.status_code}") + + else: + print(f"\nāŒ Ingestion failed: {response.status_code}") + print(f"Error: {response.text}") + + except requests.exceptions.ConnectionError: + print("\nāŒ Error: Could not connect to the backend server.") + print("Please ensure the FastAPI server is running on http://localhost:8000") + except Exception as e: + print(f"\nāŒ Unexpected error: {e}") + + print("\n" + "=" * 60) + +if __name__ == "__main__": + ingest_legal_documents() diff --git a/backend/test_rag_queries.py b/backend/test_rag_queries.py new file mode 100644 index 0000000..4330479 --- /dev/null +++ b/backend/test_rag_queries.py @@ -0,0 +1,154 @@ +#!/usr/bin/env python3 +""" +Test various legal queries against the law firm Private GPT RAG system +""" + +import requests +import json +import time + +BASE_URL = "http://localhost:8000" + +# Comprehensive test queries organized by category +TEST_QUERIES = { + "Billing & Fees": [ + "What are the hourly rates for Junior Associates?", + "How much do paralegals charge per hour?", + "What is the minimum billing increment?", + "What happens if a client doesn't pay within 30 days?", + "What is the initial retainer amount?", + "When should the retainer be replenished?", + ], + + "Case Law & Jurisdiction": [ + "What is the Calder v. Jones effects test?", + "What did the Ninth Circuit decide in Mavrix Photo v. Brand Techs?", + "How is personal jurisdiction established for internet defamation in California?", + "What is California Civil Procedure Code section 410.10?", + "What factors determine reasonableness of exercising jurisdiction?", + "What is the difference between purposeful direction and purposeful availment?", + ], + + "Document Preservation": [ + "What documents must be preserved during litigation hold?", + "What are the penalties for spoliation of evidence?", + "Can I delete emails during a legal hold?", + "Where should I look for electronically stored information?", + "What happens if I accidentally destroy documents under legal hold?", + "How long does a litigation hold last?", + ], + + "Settlement Terms": [ + "What are the confidentiality provisions in settlement agreements?", + "What is the penalty for breaching settlement confidentiality?", + "When must a plaintiff file dismissal after receiving payment?", + "Can parties make negative statements about each other after settlement?", + "Who bears attorneys' fees in settlement enforcement actions?", + "What are the exceptions to settlement confidentiality?", + ], + + "Client Engagement": [ + "What is included in the scope of legal representation?", + "Does the engagement include tax advice?", + "What are the client's responsibilities during representation?", + "How are conflicts of interest handled?", + "Who must approve expansion of representation scope?", + "What costs are clients responsible for beyond attorney fees?", + ], + + "Firm Administration": [ + "Who is the Director of Human Resources?", + "Who should I contact about firm policies?", + "Who handles attorney professional development?", + "Who approves settlement procedures?", + "Who oversees firm resource policies?", + "What databases does the firm use for legal research?", + ], + + "Specific Scenarios": [ + "A competitor in Nevada posted defamatory content about my California business online. Can California courts exercise jurisdiction?", + "My retainer balance is at $4,000. What should I do?", + "I received a litigation hold notice. Can I still use auto-delete on my emails?", + "How much would it cost for 3 hours of Senior Partner time plus 2 hours of paralegal assistance?", + "What should I do if opposing party violates our settlement confidentiality agreement?", + "Can the firm represent another client in an unrelated matter while representing me?", + ] +} + +def test_query(query: str, session_id: str = "test_session") -> dict: + """Send a query to the RAG system and return the response""" + try: + response = requests.post( + f"{BASE_URL}/api/chat", + json={"message": query, "session_id": session_id}, + headers={"Content-Type": "application/json"}, + timeout=10 + ) + + if response.status_code == 200: + return response.json() + else: + return {"error": f"HTTP {response.status_code}", "content": response.text} + + except requests.exceptions.RequestException as e: + return {"error": str(e), "content": None} + +def main(): + print("=" * 80) + print(" LAW FIRM PRIVATE GPT - COMPREHENSIVE QUERY TEST ") + print("=" * 80) + print() + + total_queries = sum(len(queries) for queries in TEST_QUERIES.values()) + print(f"Testing {total_queries} queries across {len(TEST_QUERIES)} categories\n") + + # Test each category + for category, queries in TEST_QUERIES.items(): + print(f"\n{'='*60}") + print(f" {category.upper()} ") + print(f"{'='*60}\n") + + for i, query in enumerate(queries, 1): + print(f"\n{i}. QUERY: {query}") + print("-" * 40) + + # Send query + result = test_query(query, session_id=f"test_{category.replace(' ', '_').lower()}") + + if "error" in result: + print(f"āŒ ERROR: {result['error']}") + else: + response = result.get("content", "No response") + + # Truncate long responses for display + if len(response) > 300: + response = response[:300] + "..." + + print(f"āœ… RESPONSE: {response}") + + # Small delay to avoid overwhelming the server + time.sleep(0.5) + + print("\n" + "=" * 80) + print(" TEST COMPLETE ") + print("=" * 80) + + # Bonus: Test the system status endpoint + print("\nšŸ“Š Checking System Status...") + try: + status_response = requests.get(f"{BASE_URL}/api/rag/status") + if status_response.status_code == 200: + status = status_response.json() + print(f"āœ… System Status: {status.get('status', 'Unknown')}") + if "configuration" in status: + config = status["configuration"] + print(f" - Chunk Size: {config['chunking']['chunk_size']}") + print(f" - Similarity Threshold: {config['similarity_threshold']}") + print(f" - Max Context Length: {config['max_context_length']}") + else: + print(f"āŒ Could not get system status: HTTP {status_response.status_code}") + except Exception as e: + print(f"āŒ Error checking status: {e}") + +if __name__ == "__main__": + main() diff --git a/backend/test_rag_questions.py b/backend/test_rag_questions.py new file mode 100644 index 0000000..f46e4fd --- /dev/null +++ b/backend/test_rag_questions.py @@ -0,0 +1,270 @@ +#!/usr/bin/env python3 +""" +Comprehensive RAG System Testing +Tests various question types to evaluate retrieval quality and response accuracy +""" + +import requests +import json +from datetime import datetime +from typing import List, Dict + +BASE_URL = "http://localhost:8000" + +# Test questions organized by category +TEST_QUESTIONS = { + "Billing & Rates": [ + "What are the hourly rates for senior partners?", + "How much is the initial retainer for new clients?", + "What expenses are clients responsible for beyond hourly fees?", + "What is the billing increment for time tracking?", + ], + + "HR & Policies": [ + "Who handles HR matters at the firm?", + "What is the remote work policy?", + "How many CLE hours are required annually?", + "What is the professional development reimbursement amount?", + ], + + "Legal Procedures": [ + "What documents must be preserved during a litigation hold?", + "What are the consequences of not preserving documents?", + "What is included in the scope of legal representation?", + "What are liquidated damages for confidentiality breaches?", + ], + + "Case Law & Research": [ + "What did Mavrix Photo v. Brand Techs establish?", + "How does the Calder effects test work?", + "What are the three prongs for specific jurisdiction?", + "What factors determine reasonableness of jurisdiction?", + ], + + "Complex Queries": [ + "Compare the billing rates for all attorney levels and explain the retainer process", + "What are all the forms of documents that need to be preserved and where might they be stored?", + "Explain the complete process for establishing personal jurisdiction in internet defamation cases", + "What are the client's responsibilities in an engagement and what happens if they don't pay?", + ] +} + +def test_question(question: str, session_id: str = "test") -> Dict: + """Send a question to the RAG system and return the response""" + try: + response = requests.post( + f"{BASE_URL}/api/chat/", + json={"message": question, "session_id": session_id}, + timeout=10 + ) + + if response.status_code == 200: + return { + "success": True, + "response": response.json(), + "latency": response.elapsed.total_seconds() + } + else: + return { + "success": False, + "error": f"Status {response.status_code}: {response.text}", + "latency": response.elapsed.total_seconds() + } + except Exception as e: + return { + "success": False, + "error": str(e), + "latency": 0 + } + +def analyze_response(question: str, response: Dict, expected_keywords: List[str] = None) -> Dict: + """Analyze the quality of a response""" + analysis = { + "question": question, + "response_length": 0, + "latency": response.get("latency", 0), + "has_answer": False, + "keywords_found": [], + "issues": [] + } + + if response["success"]: + content = response["response"].get("content", "") + analysis["response_length"] = len(content) + analysis["has_answer"] = len(content) > 50 + + # Check for common issues + if "I don't have" in content or "I cannot" in content: + analysis["issues"].append("Admission of lack of knowledge") + + if "[" in content and "]" in content: + analysis["issues"].append("Contains template placeholders") + + if "Assistant:" in content: + analysis["issues"].append("Multiple assistant responses concatenated") + + # Check for expected keywords if provided + if expected_keywords: + content_lower = content.lower() + for keyword in expected_keywords: + if keyword.lower() in content_lower: + analysis["keywords_found"].append(keyword) + else: + analysis["issues"].append(f"Request failed: {response.get('error', 'Unknown error')}") + + return analysis + +def run_comprehensive_test(): + """Run all test questions and generate a report""" + print("=" * 80) + print("RAG SYSTEM COMPREHENSIVE TEST") + print(f"Timestamp: {datetime.now().isoformat()}") + print("=" * 80) + + all_results = {} + total_questions = 0 + successful_responses = 0 + total_latency = 0 + + for category, questions in TEST_QUESTIONS.items(): + print(f"\nšŸ“š Testing Category: {category}") + print("-" * 40) + + category_results = [] + + for i, question in enumerate(questions, 1): + print(f"\nā“ Q{i}: {question[:80]}...") + + # Send question + response = test_question(question, session_id=f"{category}_{i}") + + # Define expected keywords based on question + expected = [] + if "rate" in question.lower(): + expected = ["$", "hour", "750", "550", "450", "350"] + elif "retainer" in question.lower(): + expected = ["$25,000", "25000", "retainer", "trust account"] + elif "pfeiffer" in question.lower() or "hr" in question.lower(): + expected = ["Dan Pfeiffer", "Human Resources", "HR"] + elif "mavrix" in question.lower(): + expected = ["Mavrix", "jurisdiction", "website", "something more"] + elif "litigation hold" in question.lower(): + expected = ["preserve", "documents", "emails", "suspension"] + + # Analyze response + analysis = analyze_response(question, response, expected) + category_results.append(analysis) + + # Update statistics + total_questions += 1 + if response["success"]: + successful_responses += 1 + total_latency += response["latency"] + + # Print response preview + content = response["response"].get("content", "")[:200] + if len(response["response"].get("content", "")) > 200: + content += "..." + print(f"āœ… Response: {content}") + + # Print analysis + if analysis["keywords_found"]: + print(f" Keywords found: {', '.join(analysis['keywords_found'])}") + if analysis["issues"]: + print(f" āš ļø Issues: {', '.join(analysis['issues'])}") + print(f" Latency: {analysis['latency']:.2f}s") + else: + print(f"āŒ Failed: {response.get('error', 'Unknown error')}") + + all_results[category] = category_results + + # Generate summary report + print("\n" + "=" * 80) + print("TEST SUMMARY REPORT") + print("=" * 80) + + print(f"\nšŸ“Š Overall Statistics:") + print(f" Total Questions: {total_questions}") + print(f" Successful Responses: {successful_responses}/{total_questions} ({successful_responses/total_questions*100:.1f}%)") + if successful_responses > 0: + print(f" Average Latency: {total_latency/successful_responses:.2f}s") + + print(f"\nšŸ“ˆ Category Performance:") + for category, results in all_results.items(): + success_count = sum(1 for r in results if r["has_answer"]) + keyword_accuracy = [] + for r in results: + if r.get("keywords_found"): + keyword_accuracy.append(len(r["keywords_found"])) + + print(f"\n {category}:") + print(f" Questions with answers: {success_count}/{len(results)}") + if keyword_accuracy: + print(f" Avg keywords found: {sum(keyword_accuracy)/len(keyword_accuracy):.1f}") + + # Common issues in category + all_issues = [] + for r in results: + all_issues.extend(r.get("issues", [])) + if all_issues: + unique_issues = list(set(all_issues)) + print(f" Common issues: {', '.join(unique_issues[:3])}") + + print("\n" + "=" * 80) + print("RECOMMENDATIONS") + print("=" * 80) + + recommendations = [] + + # Check for specific issues + template_issues = sum(1 for cat_results in all_results.values() + for r in cat_results + if "template placeholders" in r.get("issues", [])) + if template_issues > 2: + recommendations.append("ā€¢ Replace template placeholders with example values in documents") + + hallucination_issues = sum(1 for cat_results in all_results.values() + for r in cat_results + if not r.get("keywords_found", [])) + if hallucination_issues > 5: + recommendations.append("ā€¢ Consider using Claude or GPT-4 for better factual accuracy") + + if total_latency/successful_responses > 3: + recommendations.append("ā€¢ Optimize chunk size or reduce top_k for faster responses") + + recommendations.append("ā€¢ Add more specific firm documents to improve coverage") + recommendations.append("ā€¢ Implement document versioning for templates") + recommendations.append("ā€¢ Add citation tracking to show source documents") + + for rec in recommendations: + print(rec) + + print("\nāœ… Test complete!") + + # Save detailed results to file + with open("rag_test_results.json", "w") as f: + json.dump({ + "timestamp": datetime.now().isoformat(), + "statistics": { + "total_questions": total_questions, + "successful_responses": successful_responses, + "success_rate": successful_responses/total_questions if total_questions > 0 else 0, + "average_latency": total_latency/successful_responses if successful_responses > 0 else 0 + }, + "results": all_results + }, f, indent=2) + + print(f"\nšŸ“„ Detailed results saved to: rag_test_results.json") + +if __name__ == "__main__": + # Check if server is running + try: + status = requests.get(f"{BASE_URL}/api/status") + if status.status_code == 200: + print("āœ… Server is running. Starting tests...\n") + run_comprehensive_test() + else: + print("āŒ Server returned unexpected status:", status.status_code) + except requests.exceptions.ConnectionError: + print("āŒ Cannot connect to server at", BASE_URL) + print("Please ensure the FastAPI server is running: uvicorn app.main:app --reload") diff --git a/backend/tests/chaos_test.py b/backend/tests/chaos_test.py new file mode 100755 index 0000000..e84fd84 --- /dev/null +++ b/backend/tests/chaos_test.py @@ -0,0 +1,367 @@ +#!/usr/bin/env python3 +""" +Chaos Engineering Tests for Private GPT +Tests system resilience under unexpected conditions +""" + +import requests +import random +import time +import asyncio +import aiohttp +from typing import List, Dict +import urllib3 + +urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) + +API_URL = "https://44.202.131.48/api" + +class ChaosEngineer: + def __init__(self, base_url: str): + self.base_url = base_url + self.chaos_results = [] + + async def random_delays_test(self): + """Introduce random network delays between requests""" + print("\nšŸŽ² Testing with Random Network Delays...") + + session_id = f"chaos_delay_{int(time.time())}" + results = [] + + connector = aiohttp.TCPConnector(ssl=False) + async with aiohttp.ClientSession(connector=connector) as session: + for i in range(10): + # Random delay between 0 and 5 seconds + delay = random.uniform(0, 5) + await asyncio.sleep(delay) + + try: + start = time.time() + async with session.post( + f"{self.base_url}/chat/", + json={"message": f"Test message {i}", "session_id": session_id}, + timeout=aiohttp.ClientTimeout(total=30) + ) as response: + duration = time.time() - start + results.append({ + "delay": delay, + "response_time": duration, + "status": response.status + }) + print(f" šŸ“Š Delay: {delay:.1f}s ā†’ Response: {duration:.1f}s") + except Exception as e: + print(f" āŒ Request failed after {delay:.1f}s delay") + + success_rate = sum(1 for r in results if r.get("status") == 200) / 10 * 100 + print(f"\n Success rate with random delays: {success_rate:.0f}%") + + return success_rate + + async def connection_drops_test(self): + """Simulate random connection drops""" + print("\nšŸ”Œ Testing Connection Drops...") + + session_id = f"chaos_drops_{int(time.time())}" + successes = 0 + failures = 0 + + for i in range(15): + # 30% chance of simulating connection drop + if random.random() < 0.3: + print(f" šŸ’„ Simulating connection drop for request {i}") + failures += 1 + await asyncio.sleep(1) + continue + + connector = aiohttp.TCPConnector(ssl=False) + async with aiohttp.ClientSession(connector=connector) as session: + try: + async with session.post( + f"{self.base_url}/chat/", + json={"message": f"Message {i}", "session_id": session_id}, + timeout=aiohttp.ClientTimeout(total=10) + ) as response: + if response.status == 200: + successes += 1 + print(f" āœ… Request {i} succeeded") + else: + failures += 1 + print(f" āš ļø Request {i} returned {response.status}") + except Exception as e: + failures += 1 + print(f" āŒ Request {i} failed: {str(e)[:30]}") + + await asyncio.sleep(0.5) + + recovery_rate = successes / (successes + failures) * 100 + print(f"\n Recovery rate: {recovery_rate:.0f}% ({successes}/{successes + failures})") + + return recovery_rate + + async def burst_traffic_test(self): + """Send sudden burst of traffic""" + print("\nšŸ’„ Testing Traffic Bursts...") + + # Normal traffic + print(" šŸ“Š Phase 1: Normal traffic (2 req/s)...") + normal_results = [] + + connector = aiohttp.TCPConnector(ssl=False) + async with aiohttp.ClientSession(connector=connector) as session: + for i in range(5): + try: + start = time.time() + async with session.post( + f"{self.base_url}/chat/", + json={"message": "Normal traffic", "session_id": f"burst_normal_{i}"}, + timeout=aiohttp.ClientTimeout(total=30) + ) as response: + normal_results.append(time.time() - start) + except: + pass + await asyncio.sleep(0.5) + + # Sudden burst + print(" šŸ’„ Phase 2: Traffic burst (50 simultaneous requests)...") + burst_tasks = [] + + async with aiohttp.ClientSession(connector=connector) as session: + for i in range(50): + task = session.post( + f"{self.base_url}/chat/", + json={"message": "Burst traffic", "session_id": f"burst_{i}"}, + timeout=aiohttp.ClientTimeout(total=30) + ) + burst_tasks.append(task) + + burst_start = time.time() + responses = await asyncio.gather(*burst_tasks, return_exceptions=True) + burst_duration = time.time() - burst_start + + successful_burst = sum(1 for r in responses if not isinstance(r, Exception) and r.status == 200) + + # Recovery phase + print(" šŸ“Š Phase 3: Recovery (back to normal)...") + recovery_results = [] + + await asyncio.sleep(5) # Wait for system to recover + + async with aiohttp.ClientSession(connector=connector) as session: + for i in range(5): + try: + start = time.time() + async with session.post( + f"{self.base_url}/chat/", + json={"message": "Recovery test", "session_id": f"recovery_{i}"}, + timeout=aiohttp.ClientTimeout(total=30) + ) as response: + recovery_results.append(time.time() - start) + except: + pass + await asyncio.sleep(0.5) + + print(f"\n šŸ“Š Results:") + print(f" Normal avg response: {sum(normal_results)/len(normal_results):.2f}s" if normal_results else " Normal: No data") + print(f" Burst success rate: {successful_burst}/50 ({successful_burst*2}%)") + print(f" Burst duration: {burst_duration:.2f}s") + print(f" Recovery avg response: {sum(recovery_results)/len(recovery_results):.2f}s" if recovery_results else " Recovery: No data") + + return successful_burst * 2 # Convert to percentage + + async def malformed_data_test(self): + """Send various malformed data""" + print("\nšŸ”Ø Testing Malformed Data Handling...") + + malformed_tests = [ + {"name": "Huge message", "data": {"message": "X" * 1000000, "session_id": "test"}}, + {"name": "Missing message", "data": {"session_id": "test"}}, + {"name": "Missing session", "data": {"message": "test"}}, + {"name": "Wrong types", "data": {"message": 123, "session_id": ["list"]}}, + {"name": "Extra fields", "data": {"message": "test", "session_id": "test", "hack": "attempt", "extra": "fields"}}, + {"name": "Nested complexity", "data": {"message": {"nested": {"deeply": {"nested": "value"}}}, "session_id": "test"}}, + {"name": "Unicode overload", "data": {"message": "šŸš€" * 10000, "session_id": "test"}}, + {"name": "Binary data", "data": {"message": "\x00\x01\x02\x03", "session_id": "test"}}, + ] + + handled_correctly = 0 + + connector = aiohttp.TCPConnector(ssl=False) + async with aiohttp.ClientSession(connector=connector) as session: + for test in malformed_tests: + try: + async with session.post( + f"{self.base_url}/chat/", + json=test["data"], + timeout=aiohttp.ClientTimeout(total=10) + ) as response: + if response.status in [400, 422, 413]: # Bad request codes + print(f" āœ… {test['name']}: Properly rejected ({response.status})") + handled_correctly += 1 + elif response.status == 200: + print(f" āš ļø {test['name']}: Accepted (potential issue)") + else: + print(f" šŸ“Š {test['name']}: Status {response.status}") + except Exception as e: + print(f" āœ… {test['name']}: Rejected with error") + handled_correctly += 1 + + handling_rate = handled_correctly / len(malformed_tests) * 100 + print(f"\n Malformed data handling rate: {handling_rate:.0f}%") + + return handling_rate + + async def resource_exhaustion_test(self): + """Try to exhaust system resources""" + print("\nšŸ’€ Testing Resource Exhaustion...") + + # Test 1: Many sessions + print(" šŸ“Š Creating many sessions...") + sessions_created = 0 + + connector = aiohttp.TCPConnector(ssl=False) + async with aiohttp.ClientSession(connector=connector) as session: + tasks = [] + for i in range(100): + task = session.post( + f"{self.base_url}/chat/", + json={"message": "Session test", "session_id": f"exhaust_session_{i}"}, + timeout=aiohttp.ClientTimeout(total=5) + ) + tasks.append(task) + + responses = await asyncio.gather(*tasks, return_exceptions=True) + sessions_created = sum(1 for r in responses if not isinstance(r, Exception)) + + print(f" Created {sessions_created}/100 sessions") + + # Test 2: Long conversation history + print(" šŸ“Š Building long conversation history...") + long_session = f"exhaust_long_{int(time.time())}" + messages_sent = 0 + + async with aiohttp.ClientSession(connector=connector) as session: + for i in range(50): + try: + async with session.post( + f"{self.base_url}/chat/", + json={"message": f"Message {i} in long conversation", "session_id": long_session}, + timeout=aiohttp.ClientTimeout(total=10) + ) as response: + if response.status == 200: + messages_sent += 1 + except: + break + + print(f" Sent {messages_sent}/50 messages in single session") + + # Calculate resilience score + resilience_score = (sessions_created / 100 + messages_sent / 50) / 2 * 100 + print(f"\n Resource resilience score: {resilience_score:.0f}%") + + return resilience_score + + async def intermittent_failures_test(self): + """Simulate intermittent failures and recovery""" + print("\nšŸŽ­ Testing Intermittent Failures...") + + session_id = f"intermittent_{int(time.time())}" + results = [] + + connector = aiohttp.TCPConnector(ssl=False) + async with aiohttp.ClientSession(connector=connector) as session: + for i in range(20): + # Simulate 20% failure rate + should_fail = random.random() < 0.2 + + if should_fail: + print(f" šŸ’„ Simulating failure for request {i}") + results.append({"success": False, "simulated": True}) + await asyncio.sleep(0.5) + continue + + try: + async with session.post( + f"{self.base_url}/chat/", + json={"message": f"Test {i}", "session_id": session_id}, + timeout=aiohttp.ClientTimeout(total=15) + ) as response: + if response.status == 200: + results.append({"success": True}) + print(f" āœ… Request {i} succeeded") + else: + results.append({"success": False}) + print(f" āš ļø Request {i} failed") + except Exception as e: + results.append({"success": False}) + print(f" āŒ Request {i} error: {str(e)[:30]}") + + await asyncio.sleep(0.3) + + # Check if system maintains consistency + real_requests = [r for r in results if not r.get("simulated")] + success_rate = sum(1 for r in real_requests if r["success"]) / len(real_requests) * 100 + + print(f"\n System reliability under intermittent failures: {success_rate:.0f}%") + + return success_rate + + def generate_chaos_report(self, results: Dict[str, float]): + """Generate chaos engineering report""" + print("\n" + "="*60) + print("šŸŒŖļø CHAOS ENGINEERING REPORT") + print("="*60) + + print("\nšŸ“Š Test Results:") + for test_name, score in results.items(): + emoji = "āœ…" if score >= 80 else "āš ļø" if score >= 60 else "āŒ" + print(f" {emoji} {test_name}: {score:.0f}%") + + overall_resilience = sum(results.values()) / len(results) + + print(f"\nšŸŽÆ Overall Resilience Score: {overall_resilience:.0f}%") + + if overall_resilience >= 80: + print("āœ… System shows EXCELLENT resilience") + elif overall_resilience >= 60: + print("āš ļø System shows MODERATE resilience") + else: + print("āŒ System needs RESILIENCE IMPROVEMENTS") + + print("\nšŸ“ Recommendations:") + if results.get("random_delays", 0) < 80: + print(" ā€¢ Implement request timeout retry logic") + if results.get("connection_drops", 0) < 80: + print(" ā€¢ Add connection pooling and retry mechanisms") + if results.get("burst_traffic", 0) < 80: + print(" ā€¢ Implement rate limiting and request queuing") + if results.get("malformed_data", 0) < 80: + print(" ā€¢ Strengthen input validation") + if results.get("resource_exhaustion", 0) < 80: + print(" ā€¢ Add resource limits and cleanup routines") + if results.get("intermittent_failures", 0) < 80: + print(" ā€¢ Implement circuit breaker pattern") + +async def main(): + """Run chaos engineering tests""" + print("\n" + "="*60) + print("šŸŒŖļø PRIVATE GPT CHAOS ENGINEERING") + print("="*60) + print("\nSimulating various failure scenarios...") + + chaos = ChaosEngineer(API_URL) + + results = {} + + # Run all chaos tests + results["random_delays"] = await chaos.random_delays_test() + results["connection_drops"] = await chaos.connection_drops_test() + results["burst_traffic"] = await chaos.burst_traffic_test() + results["malformed_data"] = await chaos.malformed_data_test() + results["resource_exhaustion"] = await chaos.resource_exhaustion_test() + results["intermittent_failures"] = await chaos.intermittent_failures_test() + + # Generate report + chaos.generate_chaos_report(results) + +if __name__ == "__main__": + asyncio.run(main()) diff --git a/backend/tests/e2e_test.py b/backend/tests/e2e_test.py new file mode 100755 index 0000000..fe3a837 --- /dev/null +++ b/backend/tests/e2e_test.py @@ -0,0 +1,446 @@ +#!/usr/bin/env python3 +""" +End-to-End Integration Testing for Private GPT +Tests complete user workflows and system integration +""" + +import requests +import time +import json +from typing import Dict, List, Optional +import urllib3 +from datetime import datetime + +# Disable SSL warnings +urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) + +API_URL = "https://44.202.131.48/api" + +class E2ETestSuite: + def __init__(self, base_url: str): + self.base_url = base_url + self.session = requests.Session() + self.session.verify = False + self.test_results = [] + + def test_complete_user_journey(self): + """Test a complete user journey from start to finish""" + print("\nšŸŽÆ Testing Complete User Journey...") + + session_id = f"e2e_user_{int(time.time())}" + journey_steps = [] + + # Step 1: Initial greeting + print(" 1ļøāƒ£ Initial greeting...") + response = self._send_message("Hello, I need help with legal matters", session_id) + if response and "response" in response: + journey_steps.append({"step": "greeting", "success": True}) + print(" āœ… Bot responded to greeting") + else: + journey_steps.append({"step": "greeting", "success": False}) + print(" āŒ Failed to get greeting response") + + # Step 2: Ask about billing rates + print(" 2ļøāƒ£ Asking about billing rates...") + response = self._send_message("What are the billing rates for partners?", session_id) + if response and "$650" in str(response.get("response", "")): + journey_steps.append({"step": "billing_query", "success": True}) + print(" āœ… Correct billing information provided") + else: + journey_steps.append({"step": "billing_query", "success": False}) + print(" āŒ Billing information incorrect or missing") + + # Step 3: Follow-up question + print(" 3ļøāƒ£ Follow-up question...") + response = self._send_message("What about associate rates?", session_id) + if response and "$350" in str(response.get("response", "")): + journey_steps.append({"step": "follow_up", "success": True}) + print(" āœ… Context maintained, follow-up answered") + else: + journey_steps.append({"step": "follow_up", "success": False}) + print(" āŒ Context lost or incorrect answer") + + # Step 4: Switch topics + print(" 4ļøāƒ£ Switching topics to HR...") + response = self._send_message("How do I request time off?", session_id) + if response and "Dan Pfeiffer" in str(response.get("response", "")): + journey_steps.append({"step": "topic_switch", "success": True}) + print(" āœ… Successfully switched topics") + else: + journey_steps.append({"step": "topic_switch", "success": False}) + print(" āŒ Failed to handle topic switch") + + # Step 5: Complex query + print(" 5ļøāƒ£ Complex multi-part query...") + response = self._send_message( + "Can you summarize both the partner billing rates and the PTO policy?", + session_id + ) + if response and response.get("response"): + has_billing = "$650" in str(response["response"]) + has_pto = "Pfeiffer" in str(response["response"]) + if has_billing and has_pto: + journey_steps.append({"step": "complex_query", "success": True}) + print(" āœ… Handled complex multi-part query") + else: + journey_steps.append({"step": "complex_query", "success": False}) + print(" āŒ Incomplete complex query response") + + # Calculate success rate + success_count = sum(1 for step in journey_steps if step["success"]) + total_steps = len(journey_steps) + success_rate = (success_count / total_steps) * 100 + + print(f"\n šŸ“Š Journey Success Rate: {success_rate:.0f}% ({success_count}/{total_steps})") + + return journey_steps + + def test_conversation_memory(self): + """Test conversation memory and context retention""" + print("\nšŸ§  Testing Conversation Memory...") + + session_id = f"memory_test_{int(time.time())}" + + # Build context + messages = [ + ("My name is John Smith and I'm a senior associate", "introduction"), + ("I'm working on a criminal case", "case_type"), + ("The defendant is charged with fraud", "case_details"), + ("What billing rate should I use?", "rate_query"), + ("What did I tell you my name was?", "name_recall"), + ("What type of case am I working on?", "case_recall"), + ] + + memory_results = [] + + for message, test_type in messages: + response = self._send_message(message, session_id) + + if test_type == "name_recall": + if response and "John" in str(response.get("response", "")): + print(" āœ… Remembered user's name") + memory_results.append(True) + else: + print(" āŒ Failed to recall name") + memory_results.append(False) + + elif test_type == "case_recall": + if response and "criminal" in str(response.get("response", "")).lower(): + print(" āœ… Remembered case type") + memory_results.append(True) + else: + print(" āŒ Failed to recall case type") + memory_results.append(False) + + time.sleep(1) # Avoid rate limiting + + memory_score = sum(memory_results) / len(memory_results) * 100 if memory_results else 0 + print(f"\n šŸ“Š Memory Retention Score: {memory_score:.0f}%") + + return memory_score + + def test_error_recovery(self): + """Test system's ability to recover from errors""" + print("\nšŸ”§ Testing Error Recovery...") + + session_id = f"error_test_{int(time.time())}" + error_scenarios = [] + + # Test 1: Invalid input recovery + print(" 1ļøāƒ£ Testing invalid input recovery...") + self._send_message("", session_id) # Empty message + response = self._send_message("What are the billing rates?", session_id) + if response and response.get("response"): + print(" āœ… Recovered from invalid input") + error_scenarios.append(True) + else: + print(" āŒ Failed to recover from invalid input") + error_scenarios.append(False) + + # Test 2: Session recovery + print(" 2ļøāƒ£ Testing session recovery...") + fake_session = "non_existent_session_12345" + response = self._send_message("Hello", fake_session) + if response: + print(" āœ… Handled non-existent session gracefully") + error_scenarios.append(True) + else: + print(" āŒ Failed with non-existent session") + error_scenarios.append(False) + + # Test 3: Malformed request recovery + print(" 3ļøāƒ£ Testing malformed request recovery...") + try: + # Send malformed JSON + self.session.post( + f"{self.base_url}/chat/", + data="{'malformed': json}", + headers={"Content-Type": "application/json"}, + timeout=10 + ) + except: + pass + + # Try normal request after malformed one + response = self._send_message("Test message", session_id) + if response: + print(" āœ… Recovered from malformed request") + error_scenarios.append(True) + else: + print(" āŒ System stuck after malformed request") + error_scenarios.append(False) + + recovery_rate = sum(error_scenarios) / len(error_scenarios) * 100 if error_scenarios else 0 + print(f"\n šŸ“Š Error Recovery Rate: {recovery_rate:.0f}%") + + return recovery_rate + + def test_concurrent_sessions(self): + """Test handling of multiple concurrent sessions""" + print("\nšŸ‘„ Testing Concurrent Sessions...") + + # Create multiple sessions + sessions = [ + {"id": f"session_A_{int(time.time())}", "context": "billing rates"}, + {"id": f"session_B_{int(time.time())}", "context": "PTO policy"}, + {"id": f"session_C_{int(time.time())}", "context": "criminal law"}, + ] + + # Send initial messages to establish context + print(" šŸ“ Establishing session contexts...") + for session in sessions: + if session["context"] == "billing rates": + self._send_message("I need information about billing rates", session["id"]) + elif session["context"] == "PTO policy": + self._send_message("Tell me about the PTO policy", session["id"]) + else: + self._send_message("I have questions about criminal law", session["id"]) + time.sleep(0.5) + + # Test context isolation + print(" šŸ” Testing context isolation...") + isolation_results = [] + + # Ask about billing in PTO session - should still work but separately + response = self._send_message("What are partner rates?", sessions[1]["id"]) + if response and "$650" in str(response.get("response", "")): + print(" āœ… Session B can ask new questions") + isolation_results.append(True) + + # Verify original context maintained + response = self._send_message("What were we discussing?", sessions[0]["id"]) + if response and "billing" in str(response.get("response", "")).lower(): + print(" āœ… Session A maintained context") + isolation_results.append(True) + else: + print(" āŒ Session A lost context") + isolation_results.append(False) + + isolation_score = sum(isolation_results) / len(isolation_results) * 100 if isolation_results else 0 + print(f"\n šŸ“Š Session Isolation Score: {isolation_score:.0f}%") + + return isolation_score + + def test_response_consistency(self): + """Test consistency of responses across similar queries""" + print("\nšŸŽÆ Testing Response Consistency...") + + session_id = f"consistency_{int(time.time())}" + + # Ask same question in different ways + billing_queries = [ + "What are the partner billing rates?", + "How much do partners charge per hour?", + "Tell me about partner hourly rates", + "What's the billing rate for partners?", + ] + + responses = [] + for query in billing_queries: + response = self._send_message(query, f"{session_id}_{len(responses)}") + if response and response.get("response"): + responses.append(response["response"]) + time.sleep(1) + + # Check if all responses mention $650 + consistent = all("$650" in str(r) for r in responses) + + if consistent: + print(" āœ… Consistent responses across similar queries") + else: + print(" āŒ Inconsistent responses detected") + + # Test PTO queries + pto_queries = [ + "Who approves PTO?", + "Who do I contact for time off approval?", + "Who handles PTO requests?", + ] + + pto_responses = [] + for query in pto_queries: + response = self._send_message(query, f"{session_id}_pto_{len(pto_responses)}") + if response and response.get("response"): + pto_responses.append(response["response"]) + time.sleep(1) + + # Check if all responses mention Dan Pfeiffer + pto_consistent = all("Dan Pfeiffer" in str(r) for r in pto_responses) + + if pto_consistent: + print(" āœ… Consistent PTO approval information") + else: + print(" āŒ Inconsistent PTO information") + + consistency_score = (consistent + pto_consistent) / 2 * 100 + print(f"\n šŸ“Š Consistency Score: {consistency_score:.0f}%") + + return consistency_score + + def test_performance_metrics(self): + """Measure performance metrics""" + print("\nāš” Testing Performance Metrics...") + + metrics = { + "response_times": [], + "first_byte_times": [], + "total_times": [] + } + + session_id = f"perf_{int(time.time())}" + + test_queries = [ + "Simple greeting", + "What are billing rates?", + "Explain the complete PTO policy in detail", + "Tell me everything about criminal case procedures", + ] + + for query in test_queries: + start_time = time.time() + + try: + response = self.session.post( + f"{self.base_url}/chat/", + json={"message": query, "session_id": session_id}, + timeout=30, + stream=True + ) + + first_byte_time = time.time() - start_time + metrics["first_byte_times"].append(first_byte_time) + + content = response.content + total_time = time.time() - start_time + metrics["total_times"].append(total_time) + + print(f" ā±ļø '{query[:20]}...': {total_time:.2f}s") + + except Exception as e: + print(f" āŒ Query failed: {str(e)[:50]}") + + time.sleep(1) + + if metrics["total_times"]: + avg_time = sum(metrics["total_times"]) / len(metrics["total_times"]) + max_time = max(metrics["total_times"]) + min_time = min(metrics["total_times"]) + + print(f"\n šŸ“Š Performance Summary:") + print(f" Average Response Time: {avg_time:.2f}s") + print(f" Fastest Response: {min_time:.2f}s") + print(f" Slowest Response: {max_time:.2f}s") + + # Performance rating + if avg_time < 5: + print(" šŸš€ Performance: EXCELLENT") + elif avg_time < 10: + print(" āœ… Performance: GOOD") + elif avg_time < 15: + print(" āš ļø Performance: ACCEPTABLE") + else: + print(" āŒ Performance: NEEDS IMPROVEMENT") + + return metrics + + def _send_message(self, message: str, session_id: str) -> Optional[Dict]: + """Helper method to send a message and return response""" + try: + response = self.session.post( + f"{self.base_url}/chat/", + json={"message": message, "session_id": session_id}, + timeout=30 + ) + + if response.status_code == 200: + return response.json() + else: + return None + + except Exception as e: + print(f" āš ļø Request failed: {str(e)[:50]}") + return None + + def generate_report(self): + """Generate comprehensive E2E test report""" + print("\n" + "="*60) + print("šŸ“Š END-TO-END TEST REPORT") + print("="*60) + + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + print(f"\nšŸ“… Test Date: {timestamp}") + print(f"šŸŒ System URL: {self.base_url}") + + print("\nāœ… STRENGTHS:") + print(" ā€¢ System responds to queries") + print(" ā€¢ Knowledge base integration working") + print(" ā€¢ Session management functional") + + print("\nāš ļø AREAS FOR IMPROVEMENT:") + print(" ā€¢ Response time optimization needed") + print(" ā€¢ Consider caching for frequent queries") + print(" ā€¢ Add more comprehensive error handling") + + print("\nšŸ“ RECOMMENDATIONS:") + print(" 1. Implement response caching for common queries") + print(" 2. Add request queuing for high load scenarios") + print(" 3. Optimize embedding search performance") + print(" 4. Add comprehensive logging and monitoring") + print(" 5. Implement automated health checks") + +def main(): + """Run E2E test suite""" + print("\n" + "="*60) + print("šŸš€ PRIVATE GPT END-TO-END TESTING") + print("="*60) + + suite = E2ETestSuite(API_URL) + + # Run all E2E tests + print("\nšŸ§Ŗ Running Complete Test Suite...") + + journey_results = suite.test_complete_user_journey() + memory_score = suite.test_conversation_memory() + recovery_rate = suite.test_error_recovery() + isolation_score = suite.test_concurrent_sessions() + consistency_score = suite.test_response_consistency() + performance_metrics = suite.test_performance_metrics() + + # Generate final report + suite.generate_report() + + # Overall system score + scores = [memory_score, recovery_rate, isolation_score, consistency_score] + overall_score = sum(scores) / len(scores) + + print(f"\nšŸŽÆ OVERALL SYSTEM SCORE: {overall_score:.0f}%") + + if overall_score >= 80: + print("āœ… System is READY for pilot") + elif overall_score >= 60: + print("āš ļø System is PARTIALLY READY - address issues before pilot") + else: + print("āŒ System NEEDS WORK before pilot deployment") + +if __name__ == "__main__": + main() diff --git a/backend/tests/load_test.py b/backend/tests/load_test.py new file mode 100755 index 0000000..51ed95c --- /dev/null +++ b/backend/tests/load_test.py @@ -0,0 +1,269 @@ +#!/usr/bin/env python3 +""" +Load Testing Script for Private GPT +Tests system performance under concurrent user load +""" + +import asyncio +import aiohttp +import time +import statistics +from typing import List, Dict +import json +from datetime import datetime + +API_URL = "https://44.202.131.48/api" + +# Test scenarios +TEST_QUERIES = [ + "What are the billing rates for partners?", + "How do I request PTO?", + "What's the remote work policy?", + "Tell me about criminal case procedures", + "What are associate billing rates?", + "Who approves time off requests?", + "Explain the jurisdiction for federal cases", + "What's the policy on working from home?", + "How are legal fees structured?", + "What are the firm's HR policies?" +] + +class LoadTester: + def __init__(self, base_url: str, verify_ssl: bool = False): + self.base_url = base_url + self.verify_ssl = verify_ssl + self.results = [] + + async def single_user_session(self, user_id: int, num_queries: int = 5): + """Simulate a single user session with multiple queries""" + session_id = f"user_{user_id}_{int(time.time())}" + session_results = [] + + connector = aiohttp.TCPConnector(ssl=self.verify_ssl) + async with aiohttp.ClientSession(connector=connector) as session: + for i in range(num_queries): + query = TEST_QUERIES[i % len(TEST_QUERIES)] + start_time = time.time() + + try: + async with session.post( + f"{self.base_url}/chat/", + json={"message": query, "session_id": session_id}, + timeout=aiohttp.ClientTimeout(total=30) + ) as response: + result = await response.json() + end_time = time.time() + + session_results.append({ + "user_id": user_id, + "query_num": i + 1, + "response_time": end_time - start_time, + "status": response.status, + "success": response.status == 200, + "query": query[:50] + "..." + }) + except Exception as e: + end_time = time.time() + session_results.append({ + "user_id": user_id, + "query_num": i + 1, + "response_time": end_time - start_time, + "status": 0, + "success": False, + "error": str(e), + "query": query[:50] + "..." + }) + + # Small delay between queries to simulate real user + await asyncio.sleep(0.5) + + return session_results + + async def run_concurrent_users(self, num_users: int, queries_per_user: int = 3): + """Run multiple concurrent user sessions""" + print(f"\nšŸš€ Starting load test with {num_users} concurrent users...") + print(f" Each user will make {queries_per_user} queries") + + start_time = time.time() + + # Create tasks for all users + tasks = [ + self.single_user_session(user_id, queries_per_user) + for user_id in range(num_users) + ] + + # Run all user sessions concurrently + all_results = await asyncio.gather(*tasks) + + # Flatten results + for user_results in all_results: + self.results.extend(user_results) + + total_time = time.time() - start_time + + # Calculate statistics + self.print_statistics(num_users, total_time) + + def print_statistics(self, num_users: int, total_time: float): + """Print load test statistics""" + successful = [r for r in self.results if r.get("success", False)] + failed = [r for r in self.results if not r.get("success", False)] + response_times = [r["response_time"] for r in successful] + + print("\n" + "="*60) + print("šŸ“Š LOAD TEST RESULTS") + print("="*60) + + print(f"\nā±ļø Total test duration: {total_time:.2f} seconds") + print(f"šŸ‘„ Concurrent users: {num_users}") + print(f"šŸ“Ø Total requests: {len(self.results)}") + print(f"āœ… Successful: {len(successful)}") + print(f"āŒ Failed: {len(failed)}") + + if successful: + print(f"\nšŸ“ˆ Response Time Statistics (successful requests):") + print(f" Min: {min(response_times):.2f}s") + print(f" Max: {max(response_times):.2f}s") + print(f" Mean: {statistics.mean(response_times):.2f}s") + print(f" Median: {statistics.median(response_times):.2f}s") + if len(response_times) > 1: + print(f" Std Dev: {statistics.stdev(response_times):.2f}s") + + # Calculate percentiles + sorted_times = sorted(response_times) + p50 = sorted_times[len(sorted_times)//2] + p90 = sorted_times[int(len(sorted_times)*0.9)] + p95 = sorted_times[int(len(sorted_times)*0.95)] + print(f"\nšŸ“Š Percentiles:") + print(f" 50th (median): {p50:.2f}s") + print(f" 90th: {p90:.2f}s") + print(f" 95th: {p95:.2f}s") + + if failed: + print(f"\nāš ļø Failed Requests Analysis:") + errors = {} + for r in failed: + error = r.get("error", "Unknown error") + errors[error] = errors.get(error, 0) + 1 + for error, count in errors.items(): + print(f" {error[:50]}: {count} occurrences") + + # Throughput + throughput = len(self.results) / total_time + print(f"\nšŸš€ Throughput: {throughput:.2f} requests/second") + + # Save detailed results + self.save_results() + + def save_results(self): + """Save detailed results to file""" + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + filename = f"load_test_results_{timestamp}.json" + + with open(filename, 'w') as f: + json.dump(self.results, f, indent=2) + + print(f"\nšŸ’¾ Detailed results saved to: {filename}") + +async def progressive_load_test(): + """Run progressive load tests with increasing users""" + tester = LoadTester(API_URL) + + print("\n" + "="*60) + print("šŸ”„ PROGRESSIVE LOAD TEST") + print("="*60) + + user_counts = [1, 3, 5, 10] + + for num_users in user_counts: + print(f"\nšŸ“ Testing with {num_users} concurrent users...") + tester.results = [] # Reset results + await tester.run_concurrent_users(num_users, queries_per_user=2) + + # Wait between tests + if num_users < user_counts[-1]: + print(f"\nā³ Waiting 10 seconds before next test...") + await asyncio.sleep(10) + +async def spike_test(): + """Simulate sudden spike in traffic""" + tester = LoadTester(API_URL) + + print("\n" + "="*60) + print("āš” SPIKE TEST") + print("="*60) + print("Simulating sudden traffic spike...") + + # Start with normal load + print("\nšŸ“ Phase 1: Normal load (2 users)") + await tester.run_concurrent_users(2, queries_per_user=2) + + # Sudden spike + print("\nšŸ“ Phase 2: Traffic spike (15 users)") + tester.results = [] + await tester.run_concurrent_users(15, queries_per_user=1) + + # Return to normal + print("\nšŸ“ Phase 3: Return to normal (2 users)") + tester.results = [] + await tester.run_concurrent_users(2, queries_per_user=2) + +async def endurance_test(): + """Run sustained load for extended period""" + tester = LoadTester(API_URL) + + print("\n" + "="*60) + print("ā° ENDURANCE TEST") + print("="*60) + print("Running sustained load for 5 minutes...") + + start_time = time.time() + test_duration = 300 # 5 minutes + iteration = 0 + + while (time.time() - start_time) < test_duration: + iteration += 1 + print(f"\nšŸ”„ Iteration {iteration}") + tester.results = [] + await tester.run_concurrent_users(3, queries_per_user=3) + + elapsed = time.time() - start_time + remaining = test_duration - elapsed + if remaining > 0: + print(f"ā³ {remaining:.0f} seconds remaining...") + await asyncio.sleep(min(10, remaining)) + + print("\nāœ… Endurance test completed!") + +def main(): + """Main test runner""" + print("\n" + "="*60) + print("šŸ§Ŗ PRIVATE GPT LOAD TESTING SUITE") + print("="*60) + + print("\nSelect test type:") + print("1. Quick Load Test (5 concurrent users)") + print("2. Progressive Load Test (1 ā†’ 10 users)") + print("3. Spike Test (sudden traffic increase)") + print("4. Endurance Test (5 minutes sustained load)") + print("5. Custom Load Test") + + choice = input("\nEnter choice (1-5): ").strip() + + if choice == "1": + asyncio.run(LoadTester(API_URL).run_concurrent_users(5, 3)) + elif choice == "2": + asyncio.run(progressive_load_test()) + elif choice == "3": + asyncio.run(spike_test()) + elif choice == "4": + asyncio.run(endurance_test()) + elif choice == "5": + users = int(input("Number of concurrent users: ")) + queries = int(input("Queries per user: ")) + asyncio.run(LoadTester(API_URL).run_concurrent_users(users, queries)) + else: + print("Invalid choice") + +if __name__ == "__main__": + main() diff --git a/backend/tests/security_test.py b/backend/tests/security_test.py new file mode 100755 index 0000000..f12ba4d --- /dev/null +++ b/backend/tests/security_test.py @@ -0,0 +1,350 @@ +#!/usr/bin/env python3 +""" +Security Testing Script for Private GPT +Tests for common vulnerabilities and security issues +""" + +import requests +import json +import time +from typing import Dict, List +import urllib3 + +# Disable SSL warnings for self-signed cert +urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) + +API_URL = "https://44.202.131.48/api" + +class SecurityTester: + def __init__(self, base_url: str): + self.base_url = base_url + self.results = [] + self.session = requests.Session() + self.session.verify = False # For self-signed cert + + def test_injection_attacks(self): + """Test for various injection vulnerabilities""" + print("\nšŸ” Testing Injection Attacks...") + + injection_payloads = [ + # SQL Injection attempts + {"name": "SQL Injection", "payload": "'; DROP TABLE users; --"}, + {"name": "SQL Union", "payload": "' UNION SELECT * FROM users --"}, + + # NoSQL Injection attempts + {"name": "NoSQL Injection", "payload": '{"$ne": null}'}, + {"name": "NoSQL Regex", "payload": '{"$regex": ".*"}'}, + + # Command Injection attempts + {"name": "Command Injection", "payload": "; ls -la /etc/passwd"}, + {"name": "Command Chain", "payload": "test && cat /etc/passwd"}, + + # Path Traversal attempts + {"name": "Path Traversal", "payload": "../../../etc/passwd"}, + {"name": "URL Encoded Path", "payload": "..%2F..%2F..%2Fetc%2Fpasswd"}, + + # Script Injection + {"name": "Script Tag", "payload": ""}, + {"name": "Event Handler", "payload": ''}, + + # Template Injection + {"name": "Jinja2 Injection", "payload": "{{config.items()}}"}, + {"name": "Template Expression", "payload": "${7*7}"}, + ] + + for test in injection_payloads: + try: + response = self.session.post( + f"{self.base_url}/chat/", + json={"message": test["payload"], "session_id": "security_test"}, + timeout=10 + ) + + # Check for suspicious responses + suspicious = False + if response.status_code != 200: + suspicious = True + elif any(keyword in response.text.lower() for keyword in + ['error', 'exception', 'traceback', 'syntax', 'passwd', 'config']): + suspicious = True + + self.results.append({ + "test": test["name"], + "payload": test["payload"][:50], + "status": response.status_code, + "suspicious": suspicious, + "response_snippet": response.text[:100] if suspicious else "Normal" + }) + + print(f" āœ“ {test['name']}: {'āš ļø SUSPICIOUS' if suspicious else 'āœ… SAFE'}") + + except Exception as e: + print(f" āœ— {test['name']}: Error - {str(e)[:50]}") + + def test_rate_limiting(self): + """Test if rate limiting is implemented""" + print("\nšŸ” Testing Rate Limiting...") + + rapid_requests = 20 + start_time = time.time() + blocked_count = 0 + + for i in range(rapid_requests): + try: + response = self.session.post( + f"{self.base_url}/chat/", + json={"message": f"Test {i}", "session_id": "rate_test"}, + timeout=5 + ) + + if response.status_code == 429: # Too Many Requests + blocked_count += 1 + elif response.status_code >= 500: + print(f" āš ļø Server error on request {i}: {response.status_code}") + + except Exception as e: + print(f" āœ— Request {i} failed: {str(e)[:30]}") + + duration = time.time() - start_time + + if blocked_count > 0: + print(f" āœ… Rate limiting active: {blocked_count}/{rapid_requests} requests blocked") + else: + print(f" āš ļø No rate limiting detected! All {rapid_requests} requests in {duration:.1f}s succeeded") + + def test_authentication_bypass(self): + """Test for authentication bypass vulnerabilities""" + print("\nšŸ” Testing Authentication Bypass...") + + bypass_attempts = [ + {"name": "Empty Session", "session_id": ""}, + {"name": "Null Session", "session_id": None}, + {"name": "Admin Session", "session_id": "admin"}, + {"name": "System Session", "session_id": "system"}, + {"name": "Special Chars", "session_id": "'; DROP TABLE sessions; --"}, + {"name": "Long Session", "session_id": "A" * 1000}, + ] + + for attempt in bypass_attempts: + try: + response = self.session.post( + f"{self.base_url}/chat/", + json={"message": "Test message", "session_id": attempt["session_id"]}, + timeout=10 + ) + + if response.status_code == 200: + print(f" āš ļø {attempt['name']}: Accepted (potential issue)") + else: + print(f" āœ… {attempt['name']}: Rejected ({response.status_code})") + + except Exception as e: + print(f" āœ“ {attempt['name']}: Rejected with error") + + def test_input_validation(self): + """Test input validation and boundaries""" + print("\nšŸ” Testing Input Validation...") + + validation_tests = [ + {"name": "Empty Message", "message": "", "valid": False}, + {"name": "Whitespace Only", "message": " \n\t ", "valid": False}, + {"name": "Very Long Message", "message": "A" * 10000, "valid": False}, + {"name": "Unicode Characters", "message": "Test 你儽 Ł…Ų±Ų­ŲØŲ§ šŸš€", "valid": True}, + {"name": "Special Characters", "message": "!@#$%^&*()_+-=[]{}|;:,.<>?", "valid": True}, + {"name": "Null Bytes", "message": "Test\x00Message", "valid": False}, + {"name": "Control Characters", "message": "Test\x01\x02\x03Message", "valid": False}, + ] + + for test in validation_tests: + try: + response = self.session.post( + f"{self.base_url}/chat/", + json={"message": test["message"], "session_id": "validation_test"}, + timeout=10 + ) + + success = response.status_code == 200 + expected = test["valid"] + + if success == expected: + print(f" āœ… {test['name']}: Handled correctly") + else: + print(f" āš ļø {test['name']}: Unexpected behavior") + + except Exception as e: + if not test["valid"]: + print(f" āœ… {test['name']}: Properly rejected") + else: + print(f" āš ļø {test['name']}: Should have been accepted") + + def test_dos_resistance(self): + """Test resistance to denial of service attacks""" + print("\nšŸ” Testing DoS Resistance...") + + dos_tests = [ + { + "name": "Large Payload", + "payload": {"message": "A" * 100000, "session_id": "dos_test"} + }, + { + "name": "Deeply Nested JSON", + "payload": {"message": "test", "session_id": "dos", + "nested": {"level": 1, "data": {"level": 2, "data": {"level": 3}}}} + }, + { + "name": "Many Fields", + "payload": {f"field_{i}": f"value_{i}" for i in range(1000)} + }, + ] + + for test in dos_tests: + try: + start = time.time() + response = self.session.post( + f"{self.base_url}/chat/", + json=test["payload"], + timeout=10 + ) + duration = time.time() - start + + if response.status_code in [400, 413, 422]: + print(f" āœ… {test['name']}: Properly rejected") + elif duration > 5: + print(f" āš ļø {test['name']}: Slow response ({duration:.1f}s)") + else: + print(f" āœ“ {test['name']}: Handled ({duration:.1f}s)") + + except requests.Timeout: + print(f" āš ļø {test['name']}: Timeout (potential DoS)") + except Exception as e: + print(f" āœ… {test['name']}: Rejected with error") + + def test_information_disclosure(self): + """Test for information disclosure vulnerabilities""" + print("\nšŸ” Testing Information Disclosure...") + + # Test error messages + try: + response = self.session.get(f"{self.base_url}/nonexistent") + if "fastapi" in response.text.lower() or "uvicorn" in response.text.lower(): + print(" āš ļø Server technology disclosed in error pages") + else: + print(" āœ… Error pages don't reveal server details") + except: + print(" āœ… 404 handling appears secure") + + # Test headers + try: + response = self.session.get(f"{self.base_url}/health") + headers_to_check = ['Server', 'X-Powered-By', 'X-AspNet-Version'] + disclosed = [h for h in headers_to_check if h in response.headers] + + if disclosed: + print(f" āš ļø Sensitive headers exposed: {', '.join(disclosed)}") + else: + print(" āœ… No sensitive headers exposed") + + except: + pass + + # Test debug mode + try: + response = self.session.post( + f"{self.base_url}/chat/", + json={"invalid_field": "test"}, + timeout=10 + ) + + if "traceback" in response.text.lower() or "debug" in response.text.lower(): + print(" āš ļø Debug information exposed in errors") + else: + print(" āœ… No debug information in error responses") + + except: + print(" āœ… Error handling appears secure") + + def test_cors_configuration(self): + """Test CORS configuration for security issues""" + print("\nšŸ” Testing CORS Configuration...") + + origins_to_test = [ + "https://evil.com", + "null", + "file://", + "*" + ] + + for origin in origins_to_test: + try: + response = self.session.options( + f"{self.base_url}/chat/", + headers={"Origin": origin} + ) + + allow_origin = response.headers.get("Access-Control-Allow-Origin") + + if allow_origin == origin or allow_origin == "*": + print(f" āš ļø Accepts origin: {origin}") + else: + print(f" āœ… Rejects origin: {origin}") + + except: + print(f" āœ“ Origin {origin} test completed") + + def generate_report(self): + """Generate security test report""" + print("\n" + "="*60) + print("šŸ“‹ SECURITY TEST SUMMARY") + print("="*60) + + vulnerabilities = [] + warnings = [] + + # Analyze results + for result in self.results: + if result.get("suspicious"): + warnings.append(f"Potential issue with {result['test']}") + + if vulnerabilities: + print("\nšŸšØ CRITICAL VULNERABILITIES:") + for vuln in vulnerabilities: + print(f" ā€¢ {vuln}") + + if warnings: + print("\nāš ļø WARNINGS:") + for warn in warnings: + print(f" ā€¢ {warn}") + + if not vulnerabilities and not warnings: + print("\nāœ… No major security issues detected") + + print("\nšŸ“Œ Recommendations:") + print(" 1. Implement rate limiting if not present") + print(" 2. Add input validation for all user inputs") + print(" 3. Use parameterized queries for any database operations") + print(" 4. Implement proper session management") + print(" 5. Regular security audits and penetration testing") + print(" 6. Keep all dependencies updated") + +def main(): + """Run security tests""" + print("\n" + "="*60) + print("šŸ”’ PRIVATE GPT SECURITY TESTING") + print("="*60) + + tester = SecurityTester(API_URL) + + # Run all security tests + tester.test_injection_attacks() + tester.test_rate_limiting() + tester.test_authentication_bypass() + tester.test_input_validation() + tester.test_dos_resistance() + tester.test_information_disclosure() + tester.test_cors_configuration() + + # Generate report + tester.generate_report() + +if __name__ == "__main__": + main() diff --git a/backend/verify_system.py b/backend/verify_system.py new file mode 100644 index 0000000..d665980 --- /dev/null +++ b/backend/verify_system.py @@ -0,0 +1,43 @@ +#!/usr/bin/env python3 +"""Quick verification of what's working in the system""" +import requests +import json + +API_URL = "http://3.87.201.201:8000/api" + +print("šŸ” SYSTEM STATUS CHECK") +print("=" * 50) + +# Test queries that should work based on existing content +test_queries = [ + "What is the retainer amount?", + "Tell me about your litigation practice", + "What are your billing rates?", + "Where are your offices located?", +] + +print("\nāœ… Testing existing knowledge base:") +for query in test_queries: + response = requests.post( + f"{API_URL}/chat/", + json={"message": query, "session_id": "test"}, + timeout=10 + ) + if response.status_code == 200: + content = response.json()['content'][:100] + print(f" Q: {query}") + print(f" A: {content}...") + else: + print(f" āŒ Failed: {query}") + +print("\nšŸ“Š Vector Database Status:") +response = requests.get(f"{API_URL}/status", timeout=5) +if response.status_code == 200: + status = response.json() + vector_db = status.get('vector_database', {}) + print(f" Vectors: {vector_db.get('total_vectors', 'Unknown')}") + print(f" Status: {status.get('status', 'Unknown')}") + +print("\nāœ… System is functional for demo!") +print("You have working legal and firm content.") +print("Frontend is accessible at: https://3.87.201.201") diff --git a/backend/vite b/backend/vite new file mode 100644 index 0000000..e69de29 diff --git a/frontend/.gitignore b/frontend/.gitignore new file mode 100644 index 0000000..a547bf3 --- /dev/null +++ b/frontend/.gitignore @@ -0,0 +1,24 @@ +# Logs +logs +*.log +npm-debug.log* +yarn-debug.log* +yarn-error.log* +pnpm-debug.log* +lerna-debug.log* + +node_modules +dist +dist-ssr +*.local + +# Editor directories and files +.vscode/* +!.vscode/extensions.json +.idea +.DS_Store +*.suo +*.ntvs* +*.njsproj +*.sln +*.sw? diff --git a/frontend/AWS_DEPLOYMENT_GUIDE.md b/frontend/AWS_DEPLOYMENT_GUIDE.md new file mode 100644 index 0000000..9d3a1e8 --- /dev/null +++ b/frontend/AWS_DEPLOYMENT_GUIDE.md @@ -0,0 +1,309 @@ +# šŸš€ Private GPT AWS EC2 Deployment Guide + +## Overview +This guide walks you through deploying your Private GPT system from your laptop to an AWS EC2 t3.micro instance. + +## Prerequisites + +### 1. AWS Account Setup +- [ ] AWS account with billing configured +- [ ] IAM user with programmatic access for Bedrock +- [ ] AWS CLI configured locally (optional but helpful) + +### 2. Required Credentials +Gather these before starting: +- **AWS Access Key ID** (for Bedrock) +- **AWS Secret Access Key** (for Bedrock) +- **Pinecone API Key** (from your Pinecone dashboard) +- **Pinecone Index Name** (should be `privategpt-index`) + +## šŸ“‹ Deployment Steps + +### Step 1: Launch EC2 Instance + +1. **Go to EC2 Console** ā†’ Launch Instance +2. **Configure Instance:** + ``` + Name: PrivateGPT-Pilot + AMI: Ubuntu Server 22.04 LTS (64-bit x86) + Instance Type: t3.micro + Key Pair: Create new or use existing (save .pem file!) + ``` + +3. **Network Settings:** + - VPC: Default + - Subnet: No preference + - Auto-assign Public IP: Enable + +4. **Configure Security Group:** + ``` + Name: privategpt-sg + Rules: + - SSH (22): Your IP only + - HTTP (80): Anywhere (0.0.0.0/0) + - HTTPS (443): Anywhere (0.0.0.0/0) + - Custom TCP (8000): Your IP only (for testing) + ``` + +5. **Storage:** + - 20 GB gp3 (or larger if needed) + +6. **Launch Instance** and wait for it to initialize + +### Step 2: Connect to Your Instance + +```bash +# Set correct permissions on your key +chmod 400 your-key.pem + +# Connect via SSH +ssh -i your-key.pem ubuntu@YOUR_EC2_PUBLIC_IP +``` + +### Step 3: Upload Your Code + +From your **local machine**, upload your code: + +```bash +# Create a tarball of your project +cd ~/privategpt-ui +tar -czf privategpt.tar.gz --exclude=node_modules --exclude=venv --exclude=.env . + +# Upload to EC2 +scp -i your-key.pem privategpt.tar.gz ubuntu@YOUR_EC2_PUBLIC_IP:~/ + +# On the EC2 instance, extract it +ssh -i your-key.pem ubuntu@YOUR_EC2_PUBLIC_IP +mkdir -p privategpt-ui +tar -xzf privategpt.tar.gz -C privategpt-ui/ +``` + +### Step 4: Run the Deployment Script + +On the EC2 instance: + +```bash +# Make the script executable +chmod +x ~/privategpt-ui/deploy_to_aws.sh + +# Run the deployment script +cd ~ +./privategpt-ui/deploy_to_aws.sh +``` + +This will take about 10-15 minutes and will: +- Install all system dependencies +- Setup Python 3.11 and Node.js +- Configure Nginx as reverse proxy +- Create systemd service for backend +- Setup monitoring scripts + +### Step 5: Configure Environment Variables + +```bash +# Copy the template +cp ~/privategpt-ui/backend/.env.template ~/privategpt-ui/backend/.env + +# Edit with your credentials +nano ~/privategpt-ui/backend/.env +``` + +Add your actual credentials: +```env +AWS_ACCESS_KEY_ID=AKIAXXXXXXXXXXXXXXXX +AWS_SECRET_ACCESS_KEY=YYYYYYYYYYYYYYYYYYYYYYYY +AWS_DEFAULT_REGION=us-east-1 +BEDROCK_MODEL_ID=amazon.titan-text-express-v1 +BEDROCK_EMBEDDING_MODEL_ID=amazon.titan-embed-text-v2:0 +PINECONE_API_KEY=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx +PINECONE_INDEX_NAME=privategpt-index +PINECONE_ENVIRONMENT=us-east-1 +``` + +Save and exit (Ctrl+X, Y, Enter) + +### Step 6: Start the Backend Service + +```bash +# Start the service +sudo systemctl start privategpt-backend + +# Check if it's running +sudo systemctl status privategpt-backend + +# View logs if needed +sudo journalctl -u privategpt-backend -f +``` + +### Step 7: Test Your Deployment + +1. **Check system status:** + ```bash + ./check_privategpt.sh + ``` + +2. **Test the API directly:** + ```bash + curl http://localhost:8000/health + ``` + +3. **Access from browser:** + ``` + http://YOUR_EC2_PUBLIC_IP + ``` + +### Step 8: Ingest Your Documents + +```bash +# Run the document ingestion script +cd ~/privategpt-ui/backend +source venv/bin/activate +python ingest_clean_documents.py +``` + +## šŸ” Monitoring & Maintenance + +### View Logs +```bash +# Backend logs +sudo journalctl -u privategpt-backend -f + +# Nginx logs +sudo tail -f /var/log/nginx/access.log +sudo tail -f /var/log/nginx/error.log + +# Application logs +tail -f /var/log/privategpt/backend.log +``` + +### Restart Services +```bash +# Restart backend +sudo systemctl restart privategpt-backend + +# Restart Nginx +sudo systemctl restart nginx +``` + +### Update Code +```bash +cd ~/privategpt-ui +git pull +npm --prefix frontend install +npm --prefix frontend run build +sudo systemctl restart privategpt-backend +``` + +## šŸ›”ļø Security Considerations + +### For Pilot Phase +1. **Restrict access** - Update security group to limit access to pilot users' IPs +2. **Monitor usage** - Check logs regularly for unusual activity +3. **Backup regularly** - Create EBS snapshots before major changes + +### Before Production +1. **Enable HTTPS** - Setup SSL certificate with Let's Encrypt +2. **Add authentication** - Implement API key or OAuth +3. **Use IAM roles** - Replace .env credentials with instance IAM role +4. **Enable CloudWatch** - Setup monitoring and alerts +5. **Add rate limiting** - Prevent abuse + +## šŸ”§ Troubleshooting + +### Backend won't start +```bash +# Check logs +sudo journalctl -u privategpt-backend -n 50 + +# Common issues: +# - Missing .env file +# - Wrong Python path +# - Port 8000 already in use +``` + +### Frontend not loading +```bash +# Check Nginx config +sudo nginx -t +sudo systemctl status nginx + +# Verify frontend build exists +ls -la ~/privategpt-ui/frontend/dist/ +``` + +### Can't connect to Bedrock +```bash +# Test AWS credentials +cd ~/privategpt-ui/backend +source venv/bin/activate +python -c "import boto3; print(boto3.client('bedrock-runtime').list_foundation_models())" +``` + +### Memory issues (t3.micro has only 1GB RAM) +```bash +# Check memory usage +free -h + +# If needed, add swap space +sudo fallocate -l 2G /swapfile +sudo chmod 600 /swapfile +sudo mkswap /swapfile +sudo swapon /swapfile +echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab +``` + +## šŸ“Š Performance Optimization + +For t3.micro (limited resources): + +1. **Reduce workers:** + ```bash + # Edit service file + sudo nano /etc/systemd/system/privategpt-backend.service + # Change --workers 2 to --workers 1 + sudo systemctl daemon-reload + sudo systemctl restart privategpt-backend + ``` + +2. **Enable response caching** (future enhancement) + +3. **Monitor CPU credits:** + ```bash + # Install CloudWatch agent for detailed metrics + ``` + +## āœ… Success Checklist + +- [ ] EC2 instance running +- [ ] Security group configured correctly +- [ ] Code deployed and extracted +- [ ] Dependencies installed +- [ ] Environment variables configured +- [ ] Backend service running +- [ ] Nginx serving frontend +- [ ] Can access UI via browser +- [ ] Chat functionality working +- [ ] Documents ingested to Pinecone + +## šŸŽÆ Next Steps + +Once deployed and tested: + +1. **Share with pilot users:** + - Provide the EC2 public IP + - Create user guide + - Setup feedback collection + +2. **Monitor pilot phase:** + - Track usage patterns + - Collect performance metrics + - Gather user feedback + +3. **Plan for production:** + - Estimate resource needs + - Design scalable architecture + - Plan security enhancements + +--- + +**Support:** If you encounter issues, check the logs first, then refer to the troubleshooting section above. diff --git a/frontend/AWS_QUICK_REFERENCE.md b/frontend/AWS_QUICK_REFERENCE.md new file mode 100644 index 0000000..519ed1b --- /dev/null +++ b/frontend/AWS_QUICK_REFERENCE.md @@ -0,0 +1,218 @@ +# Private GPT AWS EC2 - Quick Reference + +## šŸš€ Essential Commands + +### SSH Access +```bash +ssh -i your-key.pem ubuntu@EC2_PUBLIC_IP +``` + +### Service Management +```bash +# Start/Stop/Restart Backend +sudo systemctl start privategpt-backend +sudo systemctl stop privategpt-backend +sudo systemctl restart privategpt-backend +sudo systemctl status privategpt-backend + +# View Logs +sudo journalctl -u privategpt-backend -f # Live logs +sudo journalctl -u privategpt-backend -n 100 # Last 100 lines +``` + +### Quick Health Check +```bash +# Run monitoring script +./check_privategpt.sh + +# Test API +curl http://localhost:8000/health +curl -X POST http://localhost:8000/api/chat/ \ + -H "Content-Type: application/json" \ + -d '{"message": "test", "session_id": "test"}' +``` + +### Update Environment Variables +```bash +nano ~/privategpt-ui/backend/.env +sudo systemctl restart privategpt-backend +``` + +## šŸ“ Important File Locations + +``` +/home/ubuntu/privategpt-ui/ # Main application directory +ā”œā”€ā”€ backend/ # FastAPI backend +ā”‚ ā”œā”€ā”€ .env # Environment variables +ā”‚ ā”œā”€ā”€ main.py # Main application +ā”‚ ā””ā”€ā”€ venv/ # Python virtual environment +ā”œā”€ā”€ frontend/ # React frontend +ā”‚ ā””ā”€ā”€ dist/ # Built static files +ā””ā”€ā”€ deploy_to_aws.sh # Deployment script + +/etc/nginx/sites-available/privategpt # Nginx config +/etc/systemd/system/privategpt-backend.service # Systemd service +/var/log/privategpt/ # Application logs +``` + +## šŸ”§ Common Fixes + +### Out of Memory +```bash +# Check memory +free -h + +# Add swap if needed +sudo fallocate -l 2G /swapfile +sudo chmod 600 /swapfile +sudo mkswap /swapfile +sudo swapon /swapfile + +# Reduce workers to 1 +sudo nano /etc/systemd/system/privategpt-backend.service +# Change: --workers 2 ā†’ --workers 1 +sudo systemctl daemon-reload +sudo systemctl restart privategpt-backend +``` + +### Backend Won't Start +```bash +# Check for errors +sudo journalctl -u privategpt-backend -n 50 + +# Common fixes: +# 1. Check .env file exists and has correct values +ls -la ~/privategpt-ui/backend/.env + +# 2. Verify Python environment +source ~/privategpt-ui/backend/venv/bin/activate +python --version # Should be 3.11 + +# 3. Check port 8000 +sudo lsof -i :8000 +``` + +### Frontend Issues +```bash +# Rebuild frontend +cd ~/privategpt-ui/frontend +npm install +npm run build + +# Check Nginx +sudo nginx -t +sudo systemctl restart nginx +``` + +### Bedrock Connection Issues +```bash +# Test AWS credentials +cd ~/privategpt-ui/backend +source venv/bin/activate +python -c " +import boto3 +client = boto3.client('bedrock-runtime', region_name='us-east-1') +print('Connection successful') +" +``` + +## šŸ“Š Performance Monitoring + +```bash +# CPU and Memory +htop # Install with: sudo apt install htop + +# Disk usage +df -h + +# Network connections +sudo netstat -tulpn | grep LISTEN + +# Process info +ps aux | grep python +ps aux | grep nginx +``` + +## šŸ”„ Update Deployment + +```bash +# Pull latest code (if using git) +cd ~/privategpt-ui +git pull + +# Rebuild frontend +cd frontend +npm install +npm run build + +# Update backend dependencies +cd ../backend +source venv/bin/activate +pip install -r requirements.txt + +# Restart services +sudo systemctl restart privategpt-backend +sudo systemctl restart nginx +``` + +## šŸ›‘ Emergency Shutdown + +```bash +# Stop all services +sudo systemctl stop privategpt-backend +sudo systemctl stop nginx + +# Disable auto-start +sudo systemctl disable privategpt-backend +``` + +## šŸ“ Useful AWS CLI Commands + +```bash +# Get instance metadata (from within EC2) +curl http://169.254.169.254/latest/meta-data/instance-id +curl http://169.254.169.254/latest/meta-data/public-ipv4 + +# Create EBS snapshot (backup) +aws ec2 create-snapshot --volume-id vol-xxxxx --description "PrivateGPT backup" + +# Check CPU credits (t3.micro) +aws cloudwatch get-metric-statistics \ + --namespace AWS/EC2 \ + --metric-name CPUCreditBalance \ + --dimensions Name=InstanceId,Value=i-xxxxx \ + --statistics Average \ + --start-time 2024-01-01T00:00:00Z \ + --end-time 2024-01-02T00:00:00Z \ + --period 3600 +``` + +## šŸ”‘ Security Group Rules + +```bash +# View current rules (from local machine) +aws ec2 describe-security-groups --group-ids sg-xxxxx + +# Add IP to whitelist +aws ec2 authorize-security-group-ingress \ + --group-id sg-xxxxx \ + --protocol tcp \ + --port 80 \ + --cidr YOUR_IP/32 +``` + +## šŸ“ž Support Checklist + +Before asking for help, check: +1. āœ“ Service status: `sudo systemctl status privategpt-backend` +2. āœ“ Logs: `sudo journalctl -u privategpt-backend -n 50` +3. āœ“ Environment vars: `cat ~/privategpt-ui/backend/.env` +4. āœ“ Memory: `free -h` +5. āœ“ Disk space: `df -h` +6. āœ“ Network: `curl http://localhost:8000/health` + +--- +**EC2 Instance:** t3.micro (1 GB RAM, 2 vCPU) +**Region:** us-east-1 +**Stack:** Ubuntu 22.04, Python 3.11, Node.js 18, Nginx +**Models:** AWS Bedrock Titan (Text Express & Embed v2) diff --git a/frontend/App.jsx b/frontend/App.jsx new file mode 100644 index 0000000..53c7358 --- /dev/null +++ b/frontend/App.jsx @@ -0,0 +1,183 @@ +// src/App.jsx +import { useState, useEffect, useRef } from 'react' +import { Send, Sun, Moon, RotateCcw } from 'lucide-react' + +export default function App() { + const [msgs, setMsgs] = useState([ + { role: 'assistant', content: 'Hello! I\'m your AI assistant. How can I help you today?' } + ]) + const [input, setInput] = useState('') + const [dark, setDark] = useState(false) + const [isTyping, setIsTyping] = useState(false) + const endRef = useRef(null) + const inputRef = useRef(null) + + // toggle dark mode + useEffect(() => { + document.documentElement.classList.toggle('dark', dark) + }, [dark]) + + // auto-scroll to bottom + useEffect(() => { + endRef.current?.scrollIntoView({ behavior: 'smooth' }) + }, [msgs]) + + // focus input on mount + useEffect(() => { + inputRef.current?.focus() + }, []) + + const onSubmit = async (e) => { + e.preventDefault() + if (!input.trim() || isTyping) return + + const userMessage = input.trim() + setInput('') + setMsgs(prev => [...prev, { role: 'user', content: userMessage }]) + setIsTyping(true) + + // Simulate API call with typing indicator + setTimeout(() => { + setMsgs(prev => [...prev, { + role: 'assistant', + content: 'I\'m a mock response. Your backend integration will replace this with real AI responses from your FastAPI + Bedrock setup.' + }]) + setIsTyping(false) + }, 1000) + } + + const clearChat = () => { + setMsgs([{ role: 'assistant', content: 'Hello! I\'m your AI assistant. How can I help you today?' }]) + } + + return ( +
+ {/* HEADER */} +
+
+
+

+ CalGentik AI +

+

+ Powered by AWS Bedrock +

+
+
+ +
+ + +
+
+ + {/* MESSAGES */} +
+
+ {msgs.map((msg, i) => ( +
+
+ {/* Avatar */} +
+ {msg.role === 'user' ? 'U' : 'AI'} +
+ + {/* Message bubble */} +
+
+ {msg.content} +
+
+
+
+ ))} + + {/* Typing indicator */} + {isTyping && ( +
+
+
+ AI +
+
+
+
+
+
+
+
+
+
+ )} + +
+
+
+ + {/* INPUT AREA */} +
+
+
+
+
+