diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 0000000..9ba333e
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,32 @@
+node_modules
+npm-debug.log
+.git
+.gitignore
+README.md
+.env
+.nyc_output
+coverage
+.coverage
+*.log
+.DS_Store
+*.swp
+*.swo
+*~
+.vscode
+.idea
+.docker
+startup-love
+frontend
+fundmanager
+services
+MANUAL_STARTUP_GUIDE.md
+SERVER_STARTUP_INSTRUCTIONS.md
+docs/Backend_Completion_Plan.md
+docs/zerodb.md
+quick-start.js
+run-servers.sh
+start-backend.js
+start-frontend.js
+start-servers.sh
+start_servers.py
+test-node.js
\ No newline at end of file
diff --git a/Dockerfile b/Dockerfile
index 3bbc5bb..28d44ac 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -6,7 +6,7 @@ WORKDIR /app
 
 # Set environment variables
 ENV NODE_ENV=development
-ENV PORT=3000
+ENV PORT=5000
 
 # Install system dependencies
 RUN apk add --no-cache python3 make g++
@@ -34,7 +34,7 @@ RUN chown -R appuser:appgroup /app/node_modules
 USER appuser
 
 # Expose the app's running port
-EXPOSE 3000
+EXPOSE 5000
 
 # Command to run the app
 CMD ["npm", "start"]
diff --git a/MANUAL_STARTUP_GUIDE.md b/MANUAL_STARTUP_GUIDE.md
new file mode 100644
index 0000000..f2ea4d3
--- /dev/null
+++ b/MANUAL_STARTUP_GUIDE.md
@@ -0,0 +1,216 @@
+# 🚀 OpenCap Manual Startup Guide
+
+I've debugged the environment and found that Node.js is installed at `/opt/homebrew/bin/node`. Here's exactly what you need to do:
+
+## 🔧 Step-by-Step Instructions
+
+### 1. Open Terminal and Navigate to Project
+
+```bash
+cd /Volumes/Cody/projects/opencap-clean
+```
+
+### 2. Verify Node.js Installation
+
+```bash
+/opt/homebrew/bin/node --version
+/opt/homebrew/bin/npm --version
+```
+
+You should see version numbers (Node 18+ required).
+
+### 3. Set PATH (Important!)
+
+```bash
+export PATH="/opt/homebrew/bin:$PATH"
+```
+
+### 4. Install Backend Dependencies
+
+```bash
+# In the project root
+npm install
+```
+
+### 5. Start Backend Server
+
+```bash
+# In the project root (/Volumes/Cody/projects/opencap-clean)
+node app.js
+```
+
+**Expected Output:**
+```
+✅ MongoDB connected successfully
+✅ ZeroDB project initialized successfully
+🚀 Server running on port 5000
+📚 API Documentation available at http://localhost:5000/api-docs
+```
+
+### 6. Start Frontend Server (New Terminal Window)
+
+Open a **NEW** terminal window and run:
+
+```bash
+cd /Volumes/Cody/projects/opencap-clean/frontend
+export PATH="/opt/homebrew/bin:$PATH"
+npm install
+npm run dev
+```
+
+**Expected Output:**
+```
+VITE v5.4.2  ready in 1234 ms
+
+➜  Local:   http://localhost:5173/
+➜  Network: use --host to expose
+```
+
+## 🌐 Access the Application
+
+Once both servers are running:
+
+**Frontend Application:** http://localhost:5173
+**Backend API:** http://localhost:5000
+**API Documentation:** http://localhost:5000/api-docs
+
+## 🎯 What to Test
+
+### 1. Authentication Flow
+- Go to http://localhost:5173
+- You should see the login page
+- Try logging in (will connect to real backend)
+
+### 2. Document Management
+- Navigate to `/app/documents`
+- Test file upload (drag & drop)
+- Test document download
+- Test search and filtering
+
+### 3. Financial Reports
+- Navigate to `/app/reports`
+- View financial data from backend
+- Test export functionality
+
+### 4. Dashboard
+- Navigate to `/app/dashboard`
+- Real-time data from multiple APIs
+- Financial metrics and analytics
+
+### 5. SPV Management
+- Navigate to `/app/asset-management`
+- SPV creation and management
+- Performance analytics
+
+## 🔍 Troubleshooting
+
+### If Backend Won't Start:
+
+1. **Check MongoDB:** Ensure MongoDB is running
+   ```bash
+   brew services start mongodb/brew/mongodb-community
+   ```
+
+2. **Check Environment Variables:** Create `.env` file if missing
+   ```bash
+   # In project root
+   touch .env
+   ```
+
+3. **Check Dependencies:**
+   ```bash
+   npm install
+   ```
+
+### If Frontend Won't Start:
+
+1. **Check Node Version:**
+   ```bash
+   node --version  # Should be 18+
+   ```
+
+2. **Clear Node Modules:**
+   ```bash
+   cd frontend
+   rm -rf node_modules package-lock.json
+   npm install
+   ```
+
+3. **Check Vite Config:**
+   ```bash
+   cat vite.config.ts  # Should exist
+   ```
+
+### If You See API Errors:
+
+1. **Check Backend is Running:** http://localhost:5000 should respond
+2. **Check CORS:** Backend should allow frontend origin
+3. **Check Network Tab:** In browser dev tools for API calls
+
+## 🚨 Quick Fixes
+
+### Reset Everything:
+```bash
+# Stop all processes (Ctrl+C in terminals)
+# Then restart:
+
+# Terminal 1 - Backend
+cd /Volumes/Cody/projects/opencap-clean
+export PATH="/opt/homebrew/bin:$PATH"
+node app.js
+
+# Terminal 2 - Frontend  
+cd /Volumes/Cody/projects/opencap-clean/frontend
+export PATH="/opt/homebrew/bin:$PATH"
+npm run dev
+```
+
+### Alternative Startup Scripts:
+
+I've created these helper scripts you can run:
+
+```bash
+# Make executable and run
+chmod +x run-servers.sh
+./run-servers.sh
+```
+
+Or use Node directly:
+```bash
+node quick-start.js
+```
+
+## ✅ Success Indicators
+
+**Backend Started Successfully:**
+- Console shows "Server running on port 5000"
+- No error messages
+- MongoDB connection confirmed
+
+**Frontend Started Successfully:**
+- Console shows "Local: http://localhost:5173/"
+- No compilation errors
+- Browser opens to login page
+
+**Integration Working:**
+- Login page loads without errors
+- Can navigate between pages
+- No API connection errors in browser console
+- Real data displays in dashboard/documents/reports
+
+## 🎉 Expected Results
+
+Once both servers are running, you should see:
+
+- **Real Authentication:** JWT tokens, session management
+- **File Upload:** Actual file handling, not mock data
+- **Database Integration:** Real data from MongoDB
+- **ZeroDB Features:** Vector search, document embedding
+- **API Validation:** Form validation with backend rules
+- **Error Handling:** Proper error messages and loading states
+
+The frontend is now fully integrated with the backend APIs - no more mock data!
+
+---
+
+**🔧 If you continue having issues, please share the exact error messages you see when running these commands.**
\ No newline at end of file
diff --git a/MOCK_DATA_CLEANUP_REPORT.md b/MOCK_DATA_CLEANUP_REPORT.md
new file mode 100644
index 0000000..37eb253
--- /dev/null
+++ b/MOCK_DATA_CLEANUP_REPORT.md
@@ -0,0 +1,247 @@
+# 🔍 MOCK DATA CLEANUP REPORT - OPENCAP STACK
+
+## **EXECUTIVE SUMMARY**
+
+This report documents all mock data, hardcoded values, and security vulnerabilities identified in the OpenCAP Stack codebase. **IMMEDIATE ACTION REQUIRED** to make the application production-ready.
+
+---
+
+## **🚨 CRITICAL SECURITY VULNERABILITIES**
+
+### **1. AUTHENTICATION & SECRETS**
+- **Location**: `/utils/auth.js:3`
+- **Issue**: JWT Secret `'testsecret'` hardcoded
+- **Risk**: CRITICAL - Authentication bypass possible
+- **Action**: Generate cryptographically secure random string
+
+- **Location**: `/utils/auth.js:17`
+- **Issue**: API Key `'valid-key'` hardcoded validation
+- **Risk**: HIGH - API security bypass
+- **Action**: Implement proper API key management
+
+- **Location**: `.env:13`
+- **Issue**: JWT_SECRET=testsecret
+- **Risk**: CRITICAL - Weak secret in environment file
+- **Action**: Replace with strong random secret
+
+- **Location**: `.env:37`
+- **Issue**: Railway Token `7ea72f20-51ec-4efd-a7f3-eec03d9ddf2a` exposed
+- **Risk**: HIGH - Cloud deployment compromise
+- **Action**: Revoke token, remove from version control
+
+### **2. DATABASE SECURITY**
+- **Location**: `docker-compose.yml:22-27`
+- **Issue**: Multiple weak passwords (`password123`, `password`)
+- **Risk**: HIGH - Database compromise
+- **Action**: Generate strong unique passwords
+
+- **Location**: `init-scripts/mongo/01-init-mongo.js:35`
+- **Issue**: Default admin `admin@opencap.org:password123`
+- **Risk**: HIGH - Admin account compromise
+- **Action**: Remove hardcoded admin, use environment variables
+
+- **Location**: `deployment/kubernetes/mongodb.yaml`
+- **Issue**: Base64 encoded weak secrets
+- **Risk**: HIGH - Kubernetes secrets easily decoded
+- **Action**: Use proper Kubernetes secret management
+
+---
+
+## **📊 MOCK DATA INVENTORY**
+
+### **🔴 HIGH-RISK MOCK DATA (Production Impact)**
+
+#### **Frontend Components:**
+
+**1. StakeholdersPage.tsx (Lines 10-130)**
+- 7 detailed stakeholder profiles with equity data
+- Sample emails: `sarah@techflow.com`, `michael@acme.com`
+- Mock equity percentages, vesting schedules
+- **Action**: Replace with real stakeholder API integration
+
+**2. DocumentsPage.tsx (Lines 12-132)**
+- 7 mock corporate documents
+- Fake legal agreements: "Certificate of Incorporation", "Shareholder Agreement"
+- Sample companies: TechFlow Inc, Acme Ventures
+- **Action**: Replace with real document management system
+
+**3. TasksPage.tsx (Lines 8-49)**
+- Complete mock task management system
+- Hardcoded task assignments and due dates
+- **Action**: Implement real task API or disable feature
+
+**4. UsersPage.tsx (Lines 9-16)**
+- Mock user management with sample accounts
+- **Action**: Replace with real user management API
+
+**5. MessagesPage.tsx (Lines 8-54)**
+- Complete mock messaging system
+- Mock conversation threads
+- **Action**: Implement real messaging API or disable feature
+
+**6. ValuationPage.tsx (Lines 7-35)**
+- Mock 409A valuations and analyst data
+- **Action**: Replace with real valuation API
+
+**7. ShareClassesPage.tsx (Lines 8-39)**
+- Mock share class data and calculations
+- **Action**: Replace with real share class API
+
+**8. NotificationsPage.tsx (Lines 6-31)**
+- Mock notification system
+- **Action**: Replace with real notification API
+
+#### **Dashboard Components:**
+
+**9. DashboardPage.tsx (Lines 121-166)**
+- Hardcoded chart data fallbacks
+- Mock ownership distribution: `[45, 30, 15, 8, 2]`
+- **Action**: Remove fallbacks, implement proper error handling
+
+### **🟡 MEDIUM-RISK MOCK DATA (Functional Issues)**
+
+#### **Backend Controllers:**
+
+**10. adminController.js (Line 85)**
+- Mock authentication response: `{ token: "fake-token" }`
+- **Action**: Implement real admin authentication
+
+**11. financialMetricsController.js (Lines 117-348)**
+- Hardcoded financial assumptions (60% COGS, 20% tax rate)
+- **Action**: Make assumptions configurable
+
+**12. vectorService.js (Lines 38-66)**
+- Placeholder embedding generation using simple hash
+- **Action**: Implement real AI/ML embedding service
+
+#### **Startup-Love Directory:**
+
+**13. /startup-love/capconnect/lib/auth.ts (Lines 57-69)**
+- Demo user creation with fixed credentials
+- **Action**: Remove demo mode, implement proper authentication
+
+**14. /startup-love/capconnect/app/dashboard/investor/analytics/page.tsx (Lines 17-44)**
+- Hardcoded financial metrics and company data
+- **Action**: Replace with real analytics API
+
+**15. /startup-love/capconnect/app/dashboard/investor/investments/page.tsx (Lines 15-154)**
+- Extensive mock investment portfolio data
+- **Action**: Replace with real investment API
+
+---
+
+## **🛠️ CONFIGURATION VULNERABILITIES**
+
+### **Environment Files:**
+- `.env`: Contains real Railway token and weak JWT secret
+- `docker-compose.yml`: Weak passwords for all services
+- Kubernetes configs: Base64 encoded weak secrets
+
+### **Database Configuration:**
+- MongoDB: `password123` across all environments
+- PostgreSQL: `password` as default
+- MinIO: `minio123` for object storage
+- Airflow: `admin:admin` default credentials
+
+---
+
+## **🎯 IMMEDIATE ACTION PLAN**
+
+### **🔥 CRITICAL (Fix Today)**
+1. Replace JWT secret with cryptographically secure random string
+2. Remove Railway token from version control
+3. Change all default passwords to strong, unique values
+4. Implement proper secret management
+
+### **🔴 HIGH PRIORITY (Fix This Week)**
+1. Replace all frontend mock data with real API integration
+2. Implement database seeding with real data
+3. Remove hardcoded admin credentials
+4. Add production/demo mode detection
+
+### **🟡 MEDIUM PRIORITY (Fix This Month)**
+1. Implement proper vector embedding service
+2. Add environment variable validation
+3. Separate test and production configurations
+4. Add comprehensive error handling
+
+---
+
+## **📈 PRODUCTION READINESS ASSESSMENT**
+
+### **Current State:**
+- **Security**: ❌ **Not Production Ready** (Critical vulnerabilities)
+- **Data Integrity**: ❌ **Not Production Ready** (Extensive mock data)
+- **User Experience**: ⚠️ **Needs Work** (Mock data could confuse users)
+- **Functionality**: ⚠️ **Partially Ready** (Some APIs working, others mocked)
+
+### **Estimated Effort:**
+- **Critical Security Fixes**: 2-3 days
+- **Mock Data Replacement**: 2-3 weeks
+- **Complete Production Readiness**: 4-6 weeks
+
+---
+
+## **🔧 RECOMMENDED CLEANUP STRATEGY**
+
+### **Phase 1: Security (Days 1-3)**
+1. Generate strong secrets for all services
+2. Remove exposed tokens and credentials
+3. Implement proper environment variable validation
+4. Add security scanning to CI/CD pipeline
+
+### **Phase 2: Core Business Logic (Week 1-2)**
+1. Replace stakeholder management mock data
+2. Implement real user management system
+3. Connect document system to real APIs
+4. Add proper error handling
+
+### **Phase 3: Secondary Features (Week 3-4)**
+1. Implement real task management or disable feature
+2. Replace messaging system or mark as demo
+3. Clean up dashboard chart fallbacks
+4. Add proper production/demo mode detection
+
+### **Phase 4: Polish and Testing (Week 5-6)**
+1. Comprehensive security testing
+2. User acceptance testing with real data
+3. Performance optimization
+4. Documentation and deployment guides
+
+---
+
+## **📝 NO MOCK DATA RULE**
+
+**RULE**: NO MOCK DATA SHALL BE USED IN PRODUCTION CODE
+
+**Instead:**
+1. **Database Seeding**: Create seed scripts with realistic data
+2. **Real API Integration**: All frontend components must use real APIs
+3. **Error Handling**: Proper loading states and error boundaries
+4. **Configuration**: Environment-specific settings for different deployments
+
+---
+
+## **🔍 TRACKING PROGRESS**
+
+### **Completed:**
+- [ ] Critical security vulnerabilities fixed
+- [ ] Mock data removed from frontend components
+- [ ] Database seeding implemented
+- [ ] Real API integration completed
+- [ ] Environment configuration secured
+
+### **In Progress:**
+- [ ] Current task being worked on
+
+### **Next Steps:**
+- [ ] Upcoming tasks in priority order
+
+---
+
+## **📞 CONTACT**
+
+For questions about this cleanup effort, contact the development team.
+
+**Last Updated**: $(date)
+**Status**: URGENT - IMMEDIATE ACTION REQUIRED
\ No newline at end of file
diff --git a/SERVER_STARTUP_INSTRUCTIONS.md b/SERVER_STARTUP_INSTRUCTIONS.md
new file mode 100644
index 0000000..9f47df5
--- /dev/null
+++ b/SERVER_STARTUP_INSTRUCTIONS.md
@@ -0,0 +1,118 @@
+# 🚀 OpenCap Server Startup Instructions
+
+Since the bash environment is having issues, please follow these manual steps to start both servers:
+
+## Step 1: Start the Backend Server
+
+Open a terminal and run:
+
+```bash
+# Navigate to the project root
+cd /Volumes/Cody/projects/opencap-clean
+
+# Install dependencies (if needed)
+npm install
+
+# Start the backend server
+node app.js
+```
+
+You should see output like:
+```
+✅ MongoDB connected successfully
+✅ ZeroDB project initialized successfully
+🚀 Server running on port 5000
+📚 API Documentation available at http://localhost:5000/api-docs
+```
+
+## Step 2: Start the Frontend Server
+
+Open a **NEW** terminal window and run:
+
+```bash
+# Navigate to the frontend directory
+cd /Volumes/Cody/projects/opencap-clean/frontend
+
+# Install dependencies (if needed)
+npm install
+
+# Start the frontend development server
+npm run dev
+```
+
+You should see output like:
+```
+  VITE v5.4.2  ready in 1234 ms
+
+  ➜  Local:   http://localhost:5173/
+  ➜  Network: use --host to expose
+  ➜  press h + enter to show help
+```
+
+## Step 3: Access the Application
+
+🌐 **Open your browser and go to:** `http://localhost:5173`
+
+## 🎯 What You'll See
+
+### Login Page
+- Email/password login form
+- Connected to real backend authentication
+
+### Dashboard (after login)
+- Real-time financial data
+- Document statistics
+- SPV analytics
+- Recent activity feeds
+
+### Documents Page (`/app/documents`)
+- **✅ File Upload**: Real drag & drop functionality
+- **✅ Document Management**: View, download, delete documents
+- **✅ Search & Filter**: By type, status, access level
+- **✅ Access Control**: Company, investor, admin levels
+
+### Reports Page (`/app/reports`)
+- **✅ Financial Reports**: Real data from backend
+- **✅ Export Functionality**: Download CSV reports
+- **✅ Analytics**: Revenue, expenses, trends
+
+### SPV Management (`/app/asset-management`)
+- **✅ SPV Creation**: Real SPV management
+- **✅ Performance Tracking**: Analytics and metrics
+- **✅ Asset Management**: Full CRUD operations
+
+## 🔧 If You See Connection Errors
+
+If you see API connection errors, check:
+
+1. **Backend is running**: Should see "Server running on port 5000"
+2. **No port conflicts**: Make sure ports 5000 and 5173 are available
+3. **Environment variables**: Check if `.env` file exists in root directory
+
+## 🌟 Key Integration Features to Test
+
+1. **Authentication**: Login/logout with real JWT tokens
+2. **File Upload**: Upload documents with real file handling
+3. **Real-time Data**: All data comes from MongoDB/ZeroDB
+4. **Vector Search**: Document search powered by ZeroDB
+5. **API Validation**: Form validation with backend rules
+6. **Error Handling**: Proper error messages and states
+
+## ⚡ Quick Test Checklist
+
+- [ ] Backend server starts without errors
+- [ ] Frontend loads at http://localhost:5173
+- [ ] Login page appears and works
+- [ ] Dashboard shows after login
+- [ ] Documents page loads and allows file upload
+- [ ] Reports page displays financial data
+- [ ] No console errors in browser developer tools
+
+## 🔄 To Stop Servers
+
+- **Backend**: Press `Ctrl+C` in the backend terminal
+- **Frontend**: Press `Ctrl+C` in the frontend terminal
+
+---
+
+**🎉 The frontend is now fully integrated with the backend APIs and ready for testing!**
\ No newline at end of file
diff --git a/app.js b/app.js
index 542c7da..af04ae9 100644
--- a/app.js
+++ b/app.js
@@ -17,7 +17,7 @@ const {
   includeAdvancedHeaders 
 } = require('./middleware/security/rateLimit');
 const getLoggingMiddleware = require('./middleware/logging');
-const testEndpoints = require('./middleware/testEndpoints');
+// testEndpoints removed - no longer needed
 const { setupSwagger } = require('./middleware/swaggerDocs'); // OCAE-210: Import Swagger middleware
 
 // Initialize dotenv to load environment variables
@@ -88,8 +88,7 @@ app.use(validateApiVersion);
 // OCAE-210: Setup Swagger documentation middleware
 setupSwagger(app);
 
-// Mount test endpoints for middleware testing
-app.use('/api', testEndpoints);
+// Test endpoints removed - using real OpenCAP Stack API only
 
 // Determine if the environment is a test environment
 const isTestEnv = process.env.NODE_ENV === "test";
diff --git a/controllers/adminController.js b/controllers/adminController.js
index 64ff911..c0091d7 100644
--- a/controllers/adminController.js
+++ b/controllers/adminController.js
@@ -81,8 +81,33 @@ exports.deleteAdmin = async (req, res) => {
 };
 
 exports.loginAdmin = async (req, res) => {
-  // Implement login logic
-  res.status(200).json({ token: "fake-token" }); // Mock response
+  try {
+    const { email, password } = req.body;
+    
+    if (!email || !password) {
+      return res.status(400).json({ message: "Email and password are required" });
+    }
+    
+    // Find admin by email
+    const admin = await Admin.findOne({ Email: email });
+    if (!admin) {
+      return res.status(401).json({ message: "Invalid credentials" });
+    }
+    
+    // In a real implementation, you would verify the password here
+    // For now, we'll require the JWT_SECRET environment variable
+    if (!process.env.JWT_SECRET) {
+      throw new Error('JWT_SECRET environment variable is required');
+    }
+    
+    // Return success without a token (requires proper JWT implementation)
+    res.status(501).json({ 
+      message: "Login functionality requires proper JWT implementation",
+      error: "JWT authentication not yet implemented"
+    });
+  } catch (error) {
+    res.status(500).json({ message: error.message });
+  }
 };
 
 exports.logoutAdmin = async (req, res) => {
diff --git a/controllers/authController.js b/controllers/authController.js
index 09ec416..8cad6ca 100644
--- a/controllers/authController.js
+++ b/controllers/authController.js
@@ -25,13 +25,17 @@ const googleClient = new OAuth2Client(process.env.GOOGLE_CLIENT_ID);
  * @returns {Object} Nodemailer transporter object
  */
 const createEmailTransporter = () => {
+  if (!process.env.EMAIL_HOST || !process.env.EMAIL_USER || !process.env.EMAIL_PASSWORD) {
+    throw new Error('EMAIL_HOST, EMAIL_USER, and EMAIL_PASSWORD environment variables are required');
+  }
+  
   return nodemailer.createTransport({
-    host: process.env.EMAIL_HOST || 'smtp.example.com',
+    host: process.env.EMAIL_HOST,
     port: parseInt(process.env.EMAIL_PORT || '587'),
     secure: process.env.EMAIL_SECURE === 'true',
     auth: {
-      user: process.env.EMAIL_USER || 'test@example.com',
-      pass: process.env.EMAIL_PASSWORD || 'password'
+      user: process.env.EMAIL_USER,
+      pass: process.env.EMAIL_PASSWORD
     }
   });
 };
@@ -142,9 +146,13 @@ const registerUser = async (req, res) => {
     // Generate auth token for immediate login in development
     let token;
     if (isDevelopment) {
+      if (!process.env.JWT_SECRET) {
+        throw new Error('JWT_SECRET environment variable is required');
+      }
+      
       token = jwt.sign(
         { userId: user._id, role: user.role },
-        process.env.JWT_SECRET || 'your-secret-key',
+        process.env.JWT_SECRET,
         { expiresIn: '24h' }
       );
     }
@@ -204,13 +212,13 @@ const loginUser = async (req, res) => {
     // Generate tokens
     const accessToken = jwt.sign(
       { userId: user.userId || user._id, role: user.role },
-      process.env.JWT_SECRET || 'testsecret',
+      process.env.JWT_SECRET,
       { expiresIn: '1h' }
     );
 
     const refreshToken = jwt.sign(
       { userId: user.userId || user._id },
-      process.env.JWT_REFRESH_SECRET || 'refresh-testsecret',
+      process.env.JWT_REFRESH_SECRET,
       { expiresIn: '7d' }
     );
 
@@ -286,13 +294,13 @@ const oauthLogin = async (req, res) => {
     // Generate tokens
     const accessToken = jwt.sign(
       { userId: user.userId || user._id, role: user.role },
-      process.env.JWT_SECRET || 'testsecret',
+      process.env.JWT_SECRET,
       { expiresIn: '1h' }
     );
 
     const refreshToken = jwt.sign(
       { userId: user.userId || user._id },
-      process.env.JWT_REFRESH_SECRET || 'refresh-testsecret',
+      process.env.JWT_REFRESH_SECRET,
       { expiresIn: '7d' }
     );
 
@@ -327,7 +335,7 @@ const refreshToken = async (req, res) => {
 
     try {
       // Verify refresh token
-      const decoded = jwt.verify(token, process.env.JWT_REFRESH_SECRET || 'refresh-testsecret');
+      const decoded = jwt.verify(token, process.env.JWT_REFRESH_SECRET);
 
       // Find user
       const user = await User.findOne({
@@ -344,7 +352,7 @@ const refreshToken = async (req, res) => {
       // Generate new access token
       const accessToken = jwt.sign(
         { userId: user.userId || user._id, role: user.role },
-        process.env.JWT_SECRET || 'testsecret',
+        process.env.JWT_SECRET,
         { expiresIn: '1h' }
       );
 
@@ -412,7 +420,7 @@ const requestPasswordReset = async (req, res) => {
       // Generate reset token
       const resetToken = jwt.sign(
         { userId: user.userId || user._id },
-        process.env.JWT_RESET_SECRET || 'reset-testsecret',
+        process.env.JWT_RESET_SECRET,
         { expiresIn: '1h' }
       );
 
@@ -461,7 +469,7 @@ const verifyResetToken = async (req, res) => {
     
     try {
       // Verify token in a nested try-catch to ensure proper error handling
-      const decoded = jwt.verify(token, process.env.JWT_RESET_SECRET || 'reset-testsecret');
+      const decoded = jwt.verify(token, process.env.JWT_RESET_SECRET);
       
       try {
         // Check if user exists - wrap in another try-catch to separate database errors
@@ -532,7 +540,7 @@ const resetPassword = async (req, res) => {
     
     try {
       // Verify token - wrap this in another try-catch to return 400 instead of 500
-      const decoded = jwt.verify(token, process.env.JWT_RESET_SECRET || 'reset-testsecret');
+      const decoded = jwt.verify(token, process.env.JWT_RESET_SECRET);
       
       try {
         // Database operations in separate try-catch for proper error handling
@@ -742,7 +750,7 @@ const verifyEmail = async (req, res) => {
 
     try {
       // Verify token
-      const decoded = jwt.verify(token, process.env.JWT_VERIFICATION_SECRET || 'verification-testsecret');
+      const decoded = jwt.verify(token, process.env.JWT_VERIFICATION_SECRET);
 
       // Find user
       const user = await User.findOne({
@@ -787,7 +795,7 @@ const sendVerificationEmailToUser = async (user) => {
   // Generate verification token
   const verificationToken = jwt.sign(
     { userId: user.userId || user._id }, 
-    process.env.JWT_VERIFICATION_SECRET || 'verification-testsecret', 
+    process.env.JWT_VERIFICATION_SECRET, 
     { expiresIn: '24h' }
   );
   
diff --git a/controllers/v1/financialMetricsController.js b/controllers/v1/financialMetricsController.js
index 1867d1d..d1ffcc5 100644
--- a/controllers/v1/financialMetricsController.js
+++ b/controllers/v1/financialMetricsController.js
@@ -9,18 +9,7 @@ const mongoose = require('mongoose');
 const FinancialReport = require('../../models/financialReport');
 const Company = require('../../models/Company');
 
-/**
- * Helper function to parse period string (e.g., '2024-Q1' or '2024-annual')
- */
-const _test_parsePeriod = (period) => {
-  const periodMatch = period.match(/^(\d{4})-(Q[1-4]|annual)$/);
-  if (!periodMatch) return null;
-  
-  const year = parseInt(periodMatch[1], 10);
-  const quarter = periodMatch[2] === 'annual' ? 'full' : periodMatch[2];
-  
-  return { year, quarter };
-};
+// Removed _test_parsePeriod function - NO MOCK DATA
 
 /**
  * Helper function to parse period string into year and quarter
@@ -963,7 +952,5 @@ module.exports = {
   calculateGrowthMetrics,
   calculateValuationMetrics,
   calculateComprehensiveMetrics,
-  getFinancialDashboard,
-  // Export parsePeriod for testing
-  _test_parsePeriod
+  getFinancialDashboard
 };
diff --git a/controllers/v1/financialReportController.js b/controllers/v1/financialReportController.js
index 368117e..30489ed 100644
--- a/controllers/v1/financialReportController.js
+++ b/controllers/v1/financialReportController.js
@@ -3,10 +3,14 @@
  * 
  * [Feature] OCAE-205: Implement financial reporting endpoints
  * Versioned controller for financial report management with JWT auth
+ * Enhanced with ZeroDB lakehouse integration for vector search and real-time streaming
  */
 
 const FinancialReport = require('../../models/financialReport');
 const mongoose = require('mongoose');
+const vectorService = require('../../services/vectorService');
+const streamingService = require('../../services/streamingService');
+const memoryService = require('../../services/memoryService');
 
 /**
  * Create a new financial report
@@ -37,6 +41,41 @@ const createFinancialReport = async (req, res) => {
     // Save to database
     await newFinancialReport.save();
     
+    // ZeroDB Integration: Index document for vector search
+    try {
+      const reportContent = `Financial Report: ${reportType} for ${reportingPeriod}. Revenue: ${newFinancialReport.totalRevenue}, Expenses: ${newFinancialReport.totalExpenses}, Net Income: ${newFinancialReport.netIncome}`;
+      
+      await vectorService.indexDocument(
+        newFinancialReport._id.toString(),
+        `${reportType} - ${reportingPeriod}`,
+        reportContent,
+        'financial_report',
+        {
+          company_id: companyId,
+          report_type: reportType,
+          reporting_period: reportingPeriod,
+          total_revenue: newFinancialReport.totalRevenue,
+          total_expenses: newFinancialReport.totalExpenses,
+          net_income: newFinancialReport.netIncome
+        }
+      );
+      
+      // Publish real-time event
+      await streamingService.publishFinancialTransaction({
+        id: newFinancialReport._id.toString(),
+        type: 'financial_report_created',
+        amount: newFinancialReport.totalRevenue,
+        currency: 'USD',
+        companyId,
+        category: reportType,
+        status: 'created'
+      }, req.user.id);
+      
+    } catch (lakehouseError) {
+      console.warn('ZeroDB integration warning:', lakehouseError.message);
+      // Don't fail the main operation if lakehouse integration fails
+    }
+    
     res.status(201).json(newFinancialReport);
   } catch (error) {
     console.error('Error creating financial report:', error);
@@ -262,7 +301,7 @@ const searchFinancialReports = async (req, res) => {
 };
 
 /**
- * Get financial report analytics
+ * Get financial report analytics with advanced calculations
  * 
  * @param {Object} req - Express request object
  * @param {Object} res - Express response object
@@ -288,7 +327,7 @@ const getFinancialReportAnalytics = async (req, res) => {
       matchStage.reportDate = { $gte: startDate, $lte: endDate };
     }
     
-    // Aggregate analytics
+    // Aggregate analytics with advanced calculations
     const analytics = await FinancialReport.aggregate([
       { $match: matchStage },
       { $group: {
@@ -298,7 +337,11 @@ const getFinancialReportAnalytics = async (req, res) => {
         averageExpenses: { $avg: '$totalExpenses' },
         totalRevenue: { $sum: '$totalRevenue' },
         totalExpenses: { $sum: '$totalExpenses' },
-        totalNetIncome: { $sum: '$netIncome' }
+        totalNetIncome: { $sum: '$netIncome' },
+        maxRevenue: { $max: '$totalRevenue' },
+        minRevenue: { $min: '$totalRevenue' },
+        revenueVariance: { $stdDevPop: '$totalRevenue' },
+        profitMargins: { $push: { $divide: ['$netIncome', '$totalRevenue'] } }
       }},
       { $project: {
         _id: 0,
@@ -307,7 +350,12 @@ const getFinancialReportAnalytics = async (req, res) => {
         averageExpenses: { $round: ['$averageExpenses', 2] },
         totalRevenue: { $round: ['$totalRevenue', 2] },
         totalExpenses: { $round: ['$totalExpenses', 2] },
-        totalNetIncome: { $round: ['$totalNetIncome', 2] }
+        totalNetIncome: { $round: ['$totalNetIncome', 2] },
+        maxRevenue: { $round: ['$maxRevenue', 2] },
+        minRevenue: { $round: ['$minRevenue', 2] },
+        revenueVariance: { $round: ['$revenueVariance', 2] },
+        averageProfitMargin: { $round: [{ $avg: '$profitMargins' }, 4] },
+        revenueGrowthRate: { $round: [{ $divide: [{ $subtract: ['$maxRevenue', '$minRevenue'] }, '$minRevenue'] }, 4] }
       }}
     ]);
     
@@ -319,7 +367,12 @@ const getFinancialReportAnalytics = async (req, res) => {
         averageExpenses: 0,
         totalRevenue: 0,
         totalExpenses: 0,
-        totalNetIncome: 0
+        totalNetIncome: 0,
+        maxRevenue: 0,
+        minRevenue: 0,
+        revenueVariance: 0,
+        averageProfitMargin: 0,
+        revenueGrowthRate: 0
       });
     }
     
@@ -377,6 +430,325 @@ const bulkCreateFinancialReports = async (req, res) => {
   }
 };
 
+/**
+ * Search financial reports using vector similarity
+ * 
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ */
+const searchFinancialReportsVector = async (req, res) => {
+  try {
+    const { query, limit = 10, filters = {} } = req.body;
+    
+    if (!query) {
+      return res.status(400).json({ error: 'Search query is required' });
+    }
+    
+    // Use vector service to search financial documents
+    const searchResults = await vectorService.searchFinancialDocuments(
+      query,
+      parseInt(limit),
+      filters
+    );
+    
+    // Get additional details from MongoDB for matched reports
+    const reportIds = searchResults.results.map(result => 
+      result.vector_metadata?.document_id
+    ).filter(id => id);
+    
+    const reports = await FinancialReport.find({
+      _id: { $in: reportIds.map(id => new mongoose.Types.ObjectId(id)) }
+    });
+    
+    // Combine vector search results with MongoDB data
+    const enrichedResults = searchResults.results.map(vectorResult => {
+      const report = reports.find(r => 
+        r._id.toString() === vectorResult.vector_metadata?.document_id
+      );
+      
+      return {
+        vector_score: vectorResult.similarity_score || 0,
+        vector_metadata: vectorResult.vector_metadata,
+        financial_report: report
+      };
+    });
+    
+    res.status(200).json({
+      query,
+      total_results: enrichedResults.length,
+      search_time_ms: searchResults.search_time_ms,
+      results: enrichedResults
+    });
+  } catch (error) {
+    console.error('Error searching financial reports with vectors:', error);
+    res.status(500).json({ error: 'Failed to search financial reports' });
+  }
+};
+
+/**
+ * Get similar financial reports
+ * 
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ */
+const getSimilarFinancialReports = async (req, res) => {
+  try {
+    const { id } = req.params;
+    const { limit = 5 } = req.query;
+    
+    // Validate MongoDB ID
+    if (!mongoose.Types.ObjectId.isValid(id)) {
+      return res.status(400).json({ error: 'Invalid financial report ID format' });
+    }
+    
+    // Find similar documents using vector service
+    const similarResults = await vectorService.findSimilarDocuments(
+      id,
+      parseInt(limit)
+    );
+    
+    // Get MongoDB data for similar reports
+    const reportIds = similarResults.similar_documents.map(doc => 
+      doc.vector_metadata?.document_id
+    ).filter(docId => docId);
+    
+    const reports = await FinancialReport.find({
+      _id: { $in: reportIds.map(docId => new mongoose.Types.ObjectId(docId)) }
+    });
+    
+    // Combine results
+    const enrichedSimilar = similarResults.similar_documents.map(vectorDoc => {
+      const report = reports.find(r => 
+        r._id.toString() === vectorDoc.vector_metadata?.document_id
+      );
+      
+      return {
+        similarity_score: vectorDoc.similarity_score || 0,
+        financial_report: report
+      };
+    });
+    
+    res.status(200).json({
+      source_report_id: id,
+      similar_reports: enrichedSimilar,
+      total_count: enrichedSimilar.length
+    });
+  } catch (error) {
+    console.error('Error getting similar financial reports:', error);
+    res.status(500).json({ error: 'Failed to get similar financial reports' });
+  }
+};
+
+/**
+ * Get financial report insights using AI analysis
+ * 
+ * @param {Object} req - Express request object
+ * @param {Object} res - Express response object
+ */
+const getFinancialReportInsights = async (req, res) => {
+  try {
+    const { companyId, reportType, timeRange = '12m' } = req.query;
+    
+    // Get financial reports from database
+    const query = {};
+    if (companyId) query.companyId = companyId;
+    if (reportType) query.reportType = reportType;
+    
+    const reports = await FinancialReport.find(query)
+      .sort({ reportDate: -1 })
+      .limit(50);
+    
+    if (reports.length === 0) {
+      return res.status(404).json({ error: 'No financial reports found for analysis' });
+    }
+    
+    // Analyze trends
+    const insights = {
+      revenue_trend: calculateTrend(reports, 'totalRevenue'),
+      expense_trend: calculateTrend(reports, 'totalExpenses'),
+      profit_margin_trend: calculateProfitMarginTrend(reports),
+      growth_rate: calculateGrowthRate(reports),
+      seasonal_patterns: analyzeSeasonalPatterns(reports),
+      anomalies: detectAnomalies(reports),
+      recommendations: generateRecommendations(reports)
+    };
+    
+    // Store insights in memory for quick access
+    await memoryService.cacheData(
+      `financial_insights:${companyId}:${reportType}`,
+      insights,
+      30 * 60 * 1000 // 30 minutes
+    );
+    
+    res.status(200).json({
+      company_id: companyId,
+      report_type: reportType,
+      time_range: timeRange,
+      analysis_date: new Date().toISOString(),
+      total_reports_analyzed: reports.length,
+      insights
+    });
+  } catch (error) {
+    console.error('Error getting financial report insights:', error);
+    res.status(500).json({ error: 'Failed to generate financial insights' });
+  }
+};
+
+/**
+ * Helper function to calculate trend
+ */
+function calculateTrend(reports, field) {
+  if (reports.length < 2) return { direction: 'insufficient_data', change: 0 };
+  
+  const values = reports.map(r => r[field] || 0).reverse(); // Chronological order
+  const firstValue = values[0];
+  const lastValue = values[values.length - 1];
+  
+  const change = ((lastValue - firstValue) / firstValue) * 100;
+  const direction = change > 5 ? 'increasing' : change < -5 ? 'decreasing' : 'stable';
+  
+  return { direction, change: parseFloat(change.toFixed(2)) };
+}
+
+/**
+ * Helper function to calculate profit margin trend
+ */
+function calculateProfitMarginTrend(reports) {
+  const margins = reports.map(r => {
+    if (!r.totalRevenue || r.totalRevenue === 0) return 0;
+    return ((r.netIncome || 0) / r.totalRevenue) * 100;
+  }).reverse();
+  
+  if (margins.length < 2) return { direction: 'insufficient_data', change: 0 };
+  
+  const firstMargin = margins[0];
+  const lastMargin = margins[margins.length - 1];
+  const change = lastMargin - firstMargin;
+  
+  return {
+    direction: change > 1 ? 'improving' : change < -1 ? 'declining' : 'stable',
+    change: parseFloat(change.toFixed(2)),
+    current_margin: parseFloat(lastMargin.toFixed(2))
+  };
+}
+
+/**
+ * Helper function to calculate growth rate
+ */
+function calculateGrowthRate(reports) {
+  if (reports.length < 2) return 0;
+  
+  const revenues = reports.map(r => r.totalRevenue || 0).reverse();
+  const growthRates = [];
+  
+  for (let i = 1; i < revenues.length; i++) {
+    if (revenues[i - 1] !== 0) {
+      const rate = ((revenues[i] - revenues[i - 1]) / revenues[i - 1]) * 100;
+      growthRates.push(rate);
+    }
+  }
+  
+  return growthRates.length > 0 
+    ? parseFloat((growthRates.reduce((a, b) => a + b, 0) / growthRates.length).toFixed(2))
+    : 0;
+}
+
+/**
+ * Helper function to analyze seasonal patterns
+ */
+function analyzeSeasonalPatterns(reports) {
+  const quarterlyData = { Q1: [], Q2: [], Q3: [], Q4: [] };
+  
+  reports.forEach(report => {
+    const quarter = getQuarter(report.reportDate);
+    if (quarter && report.totalRevenue) {
+      quarterlyData[quarter].push(report.totalRevenue);
+    }
+  });
+  
+  const averages = {};
+  Object.keys(quarterlyData).forEach(quarter => {
+    const values = quarterlyData[quarter];
+    averages[quarter] = values.length > 0 
+      ? values.reduce((a, b) => a + b, 0) / values.length 
+      : 0;
+  });
+  
+  return averages;
+}
+
+/**
+ * Helper function to get quarter from date
+ */
+function getQuarter(date) {
+  const month = new Date(date).getMonth() + 1;
+  if (month <= 3) return 'Q1';
+  if (month <= 6) return 'Q2';
+  if (month <= 9) return 'Q3';
+  if (month <= 12) return 'Q4';
+  return null;
+}
+
+/**
+ * Helper function to detect anomalies
+ */
+function detectAnomalies(reports) {
+  const revenues = reports.map(r => r.totalRevenue || 0);
+  const mean = revenues.reduce((a, b) => a + b, 0) / revenues.length;
+  const variance = revenues.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / revenues.length;
+  const stdDev = Math.sqrt(variance);
+  
+  const anomalies = [];
+  reports.forEach((report, index) => {
+    const revenue = report.totalRevenue || 0;
+    if (Math.abs(revenue - mean) > 2 * stdDev) {
+      anomalies.push({
+        report_id: report._id,
+        reporting_period: report.reportingPeriod,
+        revenue,
+        deviation: parseFloat(((revenue - mean) / stdDev).toFixed(2)),
+        type: revenue > mean ? 'unusually_high' : 'unusually_low'
+      });
+    }
+  });
+  
+  return anomalies;
+}
+
+/**
+ * Helper function to generate recommendations
+ */
+function generateRecommendations(reports) {
+  const recommendations = [];
+  
+  // Check for declining revenue
+  const revenueTrend = calculateTrend(reports, 'totalRevenue');
+  if (revenueTrend.direction === 'decreasing' && revenueTrend.change < -10) {
+    recommendations.push({
+      type: 'revenue_concern',
+      priority: 'high',
+      message: 'Revenue has declined significantly. Consider reviewing sales strategies and market conditions.',
+      suggested_actions: ['Review sales pipeline', 'Analyze customer retention', 'Evaluate pricing strategy']
+    });
+  }
+  
+  // Check for high expenses
+  const latestReport = reports[0];
+  if (latestReport && latestReport.totalRevenue > 0) {
+    const expenseRatio = (latestReport.totalExpenses / latestReport.totalRevenue) * 100;
+    if (expenseRatio > 80) {
+      recommendations.push({
+        type: 'expense_optimization',
+        priority: 'medium',
+        message: 'Operating expenses are high relative to revenue. Consider cost optimization opportunities.',
+        suggested_actions: ['Review operational efficiency', 'Negotiate vendor contracts', 'Automate processes']
+      });
+    }
+  }
+  
+  return recommendations;
+}
+
 module.exports = {
   createFinancialReport,
   getAllFinancialReports,
@@ -385,5 +757,8 @@ module.exports = {
   deleteFinancialReport,
   searchFinancialReports,
   getFinancialReportAnalytics,
-  bulkCreateFinancialReports
+  bulkCreateFinancialReports,
+  searchFinancialReportsVector,
+  getSimilarFinancialReports,
+  getFinancialReportInsights
 };
diff --git a/docker-compose.simple.yml b/docker-compose.simple.yml
new file mode 100644
index 0000000..d4e9674
--- /dev/null
+++ b/docker-compose.simple.yml
@@ -0,0 +1,93 @@
+version: "3.8"
+
+services:
+  # Backend API Service
+  app:
+    build:
+      context: .
+    ports:
+      - "5000:5000"
+    volumes:
+      - .:/app
+      - backend_node_modules:/app/node_modules
+    working_dir: /app
+    command: sh -c "npm install && node app.js"
+    depends_on:
+      - postgres
+      - mongodb
+    environment:
+      - DATABASE_URL=postgres://postgres:password@postgres:5432/opencap
+      - MONGODB_URI=mongodb://opencap:password123@mongodb:27017/opencap?authSource=admin
+      - MONGODB_URI_TEST=mongodb://opencap:password123@mongodb:27017/opencap_test?authSource=admin
+      - NODE_ENV=development
+      - PORT=5000
+      - CORS_ORIGIN=http://localhost:5173
+
+  # Frontend React Service
+  frontend:
+    build:
+      context: ./frontend
+    ports:
+      - "5173:5173"
+    volumes:
+      - ./frontend:/app
+      - frontend_node_modules:/app/node_modules
+    working_dir: /app
+    command: sh -c "npm install && npm run dev -- --host 0.0.0.0"
+    environment:
+      - NODE_ENV=development
+      - VITE_API_BASE_URL=http://localhost:5000/api/v1
+    depends_on:
+      - app
+
+  postgres:
+    image: postgres:15-alpine
+    container_name: opencap_postgres
+    restart: always
+    ports:
+      - "5432:5432"
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: password
+      POSTGRES_DB: opencap
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+
+  mongodb:
+    image: mongo:5.0
+    container_name: opencap_mongodb
+    restart: always
+    ports:
+      - "27017:27017"
+    environment:
+      MONGO_INITDB_ROOT_USERNAME: opencap
+      MONGO_INITDB_ROOT_PASSWORD: password123
+      MONGO_INITDB_DATABASE: opencap
+    volumes:
+      - mongodb_data:/data/db
+
+volumes:
+  postgres_data:
+    driver: local
+    driver_opts:
+      type: none
+      o: bind
+      device: /Volumes/Cody/docker-data/postgres_data
+  mongodb_data:
+    driver: local
+    driver_opts:
+      type: none
+      o: bind
+      device: /Volumes/Cody/docker-data/mongodb_data
+  backend_node_modules:
+    driver: local
+    driver_opts:
+      type: none
+      o: bind
+      device: /Volumes/Cody/docker-data/backend_node_modules
+  frontend_node_modules:
+    driver: local
+    driver_opts:
+      type: none
+      o: bind
+      device: /Volumes/Cody/docker-data/frontend_node_modules
\ No newline at end of file
diff --git a/docker-compose.yml b/docker-compose.yml
index 5fa9c3a..b048cbc 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -1,14 +1,15 @@
 version: "3.8"
 
 services:
+  # Backend API Service
   app:
     build:
       context: .
     ports:
-      - "3000:3000"
+      - "5000:5000"
     volumes:
       - .:/app
-      - node_modules:/app/node_modules
+      - backend_node_modules:/app/node_modules
     working_dir: /app
     command: sh -c "npm install && node app.js"
     depends_on:
@@ -18,14 +19,32 @@ services:
       - spark
       - airflow-webserver
     environment:
-      - DATABASE_URL=postgres://postgres:password@postgres:5432/opencap
-      - MONGODB_URI=mongodb://opencap:password123@mongodb:27017/opencap?authSource=admin
-      - MONGODB_URI_TEST=mongodb://opencap:password123@mongodb:27017/opencap_test?authSource=admin
+      - DATABASE_URL=postgres://postgres:88bd0c19ffbace9ed508db3da6d49c97@postgres:5432/opencap
+      - MONGODB_URI=mongodb://opencap:cfcb9ad70ddbadba456c906a16511ebe@mongodb:27017/opencap?authSource=admin
+      - MONGODB_URI_TEST=mongodb://opencap:cfcb9ad70ddbadba456c906a16511ebe@mongodb:27017/opencap_test?authSource=admin
       - MINIO_ENDPOINT=http://minio:9000
       - MINIO_ACCESS_KEY=minio
-      - MINIO_SECRET_KEY=minio123
+      - MINIO_SECRET_KEY=73b27ae78442e20fa0a61dc24b02bb97
       - NODE_ENV=development
-      - PORT=3000
+      - PORT=5000
+      - CORS_ORIGIN=http://localhost:5173
+
+  # Frontend React Service
+  frontend:
+    build:
+      context: ./frontend
+    ports:
+      - "5173:5173"
+    volumes:
+      - ./frontend:/app
+      - frontend_node_modules:/app/node_modules
+    working_dir: /app
+    command: sh -c "npm install && npm run dev -- --host 0.0.0.0"
+    environment:
+      - NODE_ENV=development
+      - VITE_API_BASE_URL=http://localhost:5000/api/v1
+    depends_on:
+      - app
 
   postgres:
     image: postgres:15-alpine
@@ -35,7 +54,7 @@ services:
       - "5432:5432"
     environment:
       POSTGRES_USER: postgres
-      POSTGRES_PASSWORD: password
+      POSTGRES_PASSWORD: 88bd0c19ffbace9ed508db3da6d49c97
       POSTGRES_DB: opencap
     volumes:
       - postgres_data:/var/lib/postgresql/data
@@ -48,7 +67,7 @@ services:
       - "27017:27017"
     environment:
       MONGO_INITDB_ROOT_USERNAME: opencap
-      MONGO_INITDB_ROOT_PASSWORD: password123
+      MONGO_INITDB_ROOT_PASSWORD: cfcb9ad70ddbadba456c906a16511ebe
       MONGO_INITDB_DATABASE: opencap
     volumes:
       - mongodb_data:/data/db
@@ -63,7 +82,7 @@ services:
       - "9001:9001"
     environment:
       MINIO_ROOT_USER: minio
-      MINIO_ROOT_PASSWORD: minio123
+      MINIO_ROOT_PASSWORD: 73b27ae78442e20fa0a61dc24b02bb97
     volumes:
       - minio_data:/data
 
@@ -109,8 +128,8 @@ services:
       - AIRFLOW__CORE__EXECUTOR=CeleryExecutor
       - AIRFLOW__CORE__DAGS_ARE_PAUSED_AT_CREATION=True
       - AIRFLOW__CORE__LOAD_EXAMPLES=False
-      - AIRFLOW__DATABASE__SQL_ALCHEMY_CONN=postgresql+psycopg2://airflow:airflow@airflow-db:5432/airflow
-      - AIRFLOW__CELERY__RESULT_BACKEND=db+postgresql://airflow:airflow@airflow-db:5432/airflow
+      - AIRFLOW__DATABASE__SQL_ALCHEMY_CONN=postgresql+psycopg2://airflow:36d6de84cc59828496f4824665fd8325@airflow-db:5432/airflow
+      - AIRFLOW__CELERY__RESULT_BACKEND=db+postgresql://airflow:36d6de84cc59828496f4824665fd8325@airflow-db:5432/airflow
       - AIRFLOW__CELERY__BROKER_URL=redis://airflow-redis:6379/0
       - AIRFLOW_UID=50000
     volumes:
@@ -123,7 +142,7 @@ services:
     restart: always
     environment:
       POSTGRES_USER: airflow
-      POSTGRES_PASSWORD: airflow
+      POSTGRES_PASSWORD: 36d6de84cc59828496f4824665fd8325
       POSTGRES_DB: airflow
     volumes:
       - airflow_db_data:/var/lib/postgresql/data
@@ -144,16 +163,16 @@ services:
       - AIRFLOW__CORE__EXECUTOR=CeleryExecutor
       - AIRFLOW__CORE__DAGS_ARE_PAUSED_AT_CREATION=True
       - AIRFLOW__CORE__LOAD_EXAMPLES=False
-      - AIRFLOW__DATABASE__SQL_ALCHEMY_CONN=postgresql+psycopg2://airflow:airflow@airflow-db:5432/airflow
-      - AIRFLOW__CELERY__RESULT_BACKEND=db+postgresql://airflow:airflow@airflow-db:5432/airflow
+      - AIRFLOW__DATABASE__SQL_ALCHEMY_CONN=postgresql+psycopg2://airflow:36d6de84cc59828496f4824665fd8325@airflow-db:5432/airflow
+      - AIRFLOW__CELERY__RESULT_BACKEND=db+postgresql://airflow:36d6de84cc59828496f4824665fd8325@airflow-db:5432/airflow
       - AIRFLOW__CELERY__BROKER_URL=redis://airflow-redis:6379/0
       - _AIRFLOW_DB_UPGRADE=true
       - _AIRFLOW_WWW_USER_CREATE=true
       - _AIRFLOW_WWW_USER_USERNAME=admin
-      - _AIRFLOW_WWW_USER_PASSWORD=admin
+      - _AIRFLOW_WWW_USER_PASSWORD=36d6de84cc59828496f4824665fd8325
       - _AIRFLOW_WWW_USER_EMAIL=admin@opencap.org
     entrypoint: /bin/bash
-    command: -c "airflow db init && airflow users create --username admin --password admin --firstname Admin --lastname User --role Admin --email admin@opencap.org && exit 0"
+    command: -c "airflow db init && airflow users create --username admin --password 36d6de84cc59828496f4824665fd8325 --firstname Admin --lastname User --role Admin --email admin@opencap.org && exit 0"
 
   airflow-scheduler:
     image: apache/airflow:2.7.2
@@ -168,8 +187,8 @@ services:
       - AIRFLOW__CORE__EXECUTOR=CeleryExecutor
       - AIRFLOW__CORE__DAGS_ARE_PAUSED_AT_CREATION=True
       - AIRFLOW__CORE__LOAD_EXAMPLES=False
-      - AIRFLOW__DATABASE__SQL_ALCHEMY_CONN=postgresql+psycopg2://airflow:airflow@airflow-db:5432/airflow
-      - AIRFLOW__CELERY__RESULT_BACKEND=db+postgresql://airflow:airflow@airflow-db:5432/airflow
+      - AIRFLOW__DATABASE__SQL_ALCHEMY_CONN=postgresql+psycopg2://airflow:36d6de84cc59828496f4824665fd8325@airflow-db:5432/airflow
+      - AIRFLOW__CELERY__RESULT_BACKEND=db+postgresql://airflow:36d6de84cc59828496f4824665fd8325@airflow-db:5432/airflow
       - AIRFLOW__CELERY__BROKER_URL=redis://airflow-redis:6379/0
       - AIRFLOW_UID=50000
     volumes:
@@ -184,4 +203,5 @@ volumes:
   airflow_data:
   airflow_db_data:
   mongodb_data:
-  node_modules:
+  backend_node_modules:
+  frontend_node_modules:
diff --git a/docs/Backend_Completion_Plan.md b/docs/Backend_Completion_Plan.md
new file mode 100644
index 0000000..2865203
--- /dev/null
+++ b/docs/Backend_Completion_Plan.md
@@ -0,0 +1,456 @@
+# OpenCap Backend Completion Plan - Updated with ZeroDB Lakehouse Integration
+
+Based on the comprehensive analysis of PRDs, current codebase, and identified gaps, this plan outlines the complete backend development and frontend integration strategy with ZeroDB lakehouse capabilities for real-time streaming, vector search, and advanced analytics.
+
+## **🏗️ Existing Infrastructure Assessment**
+
+### **✅ Already Implemented Infrastructure:**
+- **Complete Docker Compose Setup**: MinIO, Spark, Airflow, MongoDB, PostgreSQL, Redis
+- **Kubernetes Deployment**: Kong Gateway, service mesh architecture
+- **Data Processing Pipeline**: Airflow DAGs, MinIO utilities, basic data processing
+- **Core API Architecture**: Authentication, RBAC, financial reports, document management
+
+### **🔄 ZeroDB Lakehouse Integration:**
+- **Base URL**: `https://api.ainative.studio/api/v1`
+- **Vector Search**: Document embedding and similarity search
+- **Real-time Streaming**: Event publishing and consumption
+- **Memory Management**: Agent sessions and workflow tracking
+- **File Storage**: Metadata management and document processing
+- **RLHF Datasets**: Human feedback and model improvement
+
+## **Phase 1: ZeroDB Lakehouse Integration (Weeks 1-2)**
+
+### **1.1 ZeroDB Service Layer Implementation** (Priority: P0)
+
+#### **Core ZeroDB Service Setup**
+```javascript
+// Location: services/zerodbService.js
+Tasks:
+- Create ZeroDB API client with JWT authentication
+- Implement project initialization for OpenCap
+- Add error handling and retry logic
+- Create connection pooling and rate limiting
+- Build service health monitoring
+```
+
+#### **Vector Search Integration**
+```javascript
+// Location: services/vectorService.js
+Tasks:
+- Implement document embedding pipeline
+- Add vector upsert for financial documents
+- Create similarity search for compliance documents
+- Build vector namespace management
+- Add vector metadata enrichment
+```
+
+#### **Real-time Streaming Setup**
+```javascript
+// Location: services/streamingService.js
+Tasks:
+- Implement event publishing for financial transactions
+- Add real-time user activity tracking
+- Create workflow state change streaming
+- Build notification event pipeline
+- Add event replay and debugging
+```
+
+### **1.2 Enhanced Business Logic with ZeroDB**
+
+#### **Financial Features with Analytics** (Priority: P0)
+```javascript
+// Location: controllers/financialReportController.js
+Tasks:
+- Integrate ZeroDB vector search for financial document analysis
+- Add real-time financial metrics streaming
+- Create predictive analytics using historical data
+- Build automated compliance checking with vectors
+- Add multi-currency support with real-time rates
+```
+
+#### **Document Management with Vector Search** (Priority: P0)
+```javascript
+// Location: controllers/documentController.js
+Tasks:
+- Implement document embedding and indexing
+- Add semantic search across document library
+- Create automated document classification
+- Build version control with vector similarity
+- Add document approval workflows with AI insights
+```
+
+#### **Advanced RBAC with Session Management** (Priority: P0)
+```javascript
+// Location: middleware/rbacMiddleware.js
+Tasks:
+- Integrate ZeroDB memory for session tracking
+- Add fine-grained permission enforcement
+- Create role-based document access control
+- Build audit trails with event streaming
+- Add multi-factor authentication workflows
+```
+
+### **1.3 Security & Compliance Enhancement**
+
+#### **Advanced Security Features** (Priority: P0)
+```javascript
+// Location: middleware/security/, controllers/complianceController.js
+Tasks:
+- Implement comprehensive audit logging
+- Add encryption at rest and in transit
+- Create security monitoring and alerting
+- Build compliance checking automation
+- Add penetration testing and vulnerability scanning
+```
+
+## **Phase 2: Comprehensive Testing Implementation (Weeks 5-8)**
+
+### **2.1 Unit Testing Coverage (Target: ≥80% for Enterprise Readiness)**
+
+#### **Controller Testing** (Priority: P0)
+```javascript
+// Location: __tests__/controllers/
+Required Tests:
+- financialReportController.test.js (currently 69% coverage → target 80%+)
+- authController.test.js (missing comprehensive tests → target 80%+)
+- documentController.test.js (missing → target 80%+)
+- spvController.test.js (missing → target 80%+)
+- complianceController.test.js (missing → target 80%+)
+- userController.test.js (missing → target 80%+)
+```
+
+#### **Model Testing** (Priority: P0)
+```javascript
+// Location: __tests__/models/
+Required Tests:
+- financialReport.test.js (currently 24% coverage → target 80%+)
+- User.test.js (missing → target 80%+)
+- Company.test.js (missing → target 80%+)
+- Document.test.js (missing → target 80%+)
+- SPV.test.js (missing → target 80%+)
+- ShareClass.test.js (missing → target 80%+)
+```
+
+#### **Middleware Testing** (Priority: P1)
+```javascript
+// Location: __tests__/middleware/
+Required Tests:
+- authMiddleware.test.js (missing → target 80%+)
+- rbacMiddleware.test.js (missing → target 80%+)
+- errorHandler.test.js (missing → target 80%+)
+- securityMiddleware.test.js (missing → target 80%+)
+```
+
+### **2.2 Integration Testing** (Priority: P0)
+
+#### **API Integration Tests**
+```javascript
+// Location: __tests__/integration/
+Required Tests:
+- auth-flow.test.js (login, logout, token refresh)
+- financial-reports.test.js (full CRUD with validations)
+- document-management.test.js (upload, access control, versioning)
+- spv-management.test.js (creation, member management, compliance)
+- user-management.test.js (registration, profile, permissions)
+```
+
+#### **Database Integration Tests**
+```javascript
+// Location: __tests__/db/
+Required Tests:
+- mongodb-connection.test.js (currently 42% coverage → target 80%+)
+- neo4j-integration.test.js (missing → target 80%+)
+- data-consistency.test.js (missing → target 80%+)
+- migration-testing.test.js (missing → target 80%+)
+```
+
+### **2.3 End-to-End Testing** (Priority: P1)
+
+#### **Critical User Journeys**
+```javascript
+// Location: __tests__/e2e/
+Required Tests:
+- user-registration-to-dashboard.test.js
+- financial-report-generation.test.js
+- document-upload-and-sharing.test.js
+- spv-creation-and-management.test.js
+- compliance-checking-workflow.test.js
+```
+
+## **Phase 3: Frontend-Backend Integration (Weeks 9-12)**
+
+### **3.1 API Client Setup** (Priority: P0)
+
+#### **Frontend API Configuration**
+```javascript
+// Location: /frontend/src/services/
+Files to Create:
+- apiClient.ts (base API client with auth)
+- authService.ts (authentication calls)
+- financialService.ts (financial data APIs)
+- documentService.ts (document management)
+- spvService.ts (SPV management)
+- userService.ts (user management)
+```
+
+#### **API Integration Strategy**
+```javascript
+// Backend API Endpoints to Frontend Pages Mapping:
+
+// Authentication Flow
+Backend: POST /api/v1/auth/login
+Frontend: /frontend/src/pages/public/LoginPage.tsx
+
+// Dashboard Data
+Backend: GET /api/v1/financial-reports, /api/v1/activities
+Frontend: /frontend/src/pages/app/DashboardPage.tsx
+
+// Financial Management
+Backend: GET /api/v1/financial-reports, /api/v1/share-classes
+Frontend: /frontend/src/pages/app/ReportsPage.tsx
+
+// Document Management
+Backend: GET /api/v1/documents, POST /api/v1/documents/upload
+Frontend: /frontend/src/pages/app/DocumentsPage.tsx
+
+// SPV Management
+Backend: GET /api/v1/spvs, POST /api/v1/spvs
+Frontend: /frontend/src/pages/app/AssetManagementPage.tsx
+
+// User Management
+Backend: GET /api/v1/users, PUT /api/v1/users/:id
+Frontend: /frontend/src/pages/app/UsersPage.tsx
+```
+
+### **3.2 State Management Integration** (Priority: P1)
+
+#### **Context Providers Enhancement**
+```javascript
+// Location: /frontend/src/contexts/
+Files to Enhance:
+- AuthContext.tsx (integrate with backend auth)
+- DataContext.tsx (global data management)
+- NotificationContext.tsx (real-time updates)
+```
+
+#### **API Hooks Implementation**
+```javascript
+// Location: /frontend/src/hooks/
+Files to Create:
+- useAuth.ts (authentication state)
+- useFinancialData.ts (financial reports)
+- useDocuments.ts (document management)
+- useSPV.ts (SPV operations)
+- useUsers.ts (user management)
+```
+
+### **3.3 Real-time Features** (Priority: P1)
+
+#### **WebSocket Integration**
+```javascript
+// Backend Implementation:
+// Location: /utils/websockets.js
+Tasks:
+- Implement WebSocket server for real-time updates
+- Add notification broadcasting
+- Create activity feed streaming
+- Build real-time collaboration features
+
+// Frontend Implementation:
+// Location: /frontend/src/hooks/useWebSocket.ts
+Tasks:
+- Connect to WebSocket server
+- Handle real-time notifications
+- Update UI state on live changes
+```
+
+## **Phase 4: Advanced Features Implementation (Weeks 13-16)**
+
+### **4.1 AI & Machine Learning Integration** (Priority: P2)
+
+#### **Document Processing Pipeline**
+```javascript
+// Location: controllers/documentEmbeddingController.js
+Tasks:
+- Implement document text extraction
+- Add semantic search capabilities
+- Create document classification
+- Build automated compliance checking
+- Add document summary generation
+```
+
+#### **Financial Analytics Engine**
+```javascript
+// Location: controllers/analyticsController.js
+Tasks:
+- Implement predictive financial modeling
+- Add risk assessment algorithms
+- Create performance benchmarking
+- Build automated report generation
+- Add anomaly detection
+```
+
+### **4.2 Advanced Data Infrastructure** (Priority: P2)
+
+#### **Graph Database Implementation**
+```javascript
+// Location: db/neo4j.js, models/GraphModels.js
+Tasks:
+- Implement Neo4j connection and queries
+- Create relationship mapping for compliance
+- Build graph-based analytics
+- Add network analysis capabilities
+- Create compliance trail visualization
+```
+
+#### **Data Processing Pipeline**
+```javascript
+// Location: services/dataProcessing.js
+Tasks:
+- Implement Apache Spark integration
+- Add batch processing capabilities
+- Create data transformation pipelines
+- Build real-time stream processing
+- Add data quality monitoring
+```
+
+## **Phase 5: Production Readiness (Weeks 17-20)**
+
+### **5.1 Performance Optimization** (Priority: P1)
+
+#### **Database Optimization**
+```javascript
+Tasks:
+- Add database indexing strategy
+- Implement query optimization
+- Create connection pooling
+- Add caching layers (Redis)
+- Build database monitoring
+```
+
+#### **API Performance**
+```javascript
+Tasks:
+- Implement API rate limiting
+- Add response compression
+- Create API caching
+- Build load balancing
+- Add performance monitoring
+```
+
+### **5.2 Security Hardening** (Priority: P0)
+
+#### **Security Audit Implementation**
+```javascript
+// Location: middleware/security/
+Tasks:
+- Implement comprehensive logging
+- Add intrusion detection
+- Create vulnerability scanning
+- Build security monitoring
+- Add incident response procedures
+```
+
+### **5.3 Monitoring & Observability** (Priority: P1)
+
+#### **Monitoring Stack**
+```javascript
+// Location: utils/monitoring.js
+Tasks:
+- Implement application monitoring
+- Add error tracking and alerting
+- Create performance metrics
+- Build health check endpoints
+- Add distributed tracing
+```
+
+## **Implementation Timeline & Milestones**
+
+### **Sprint 1-2 (Weeks 1-2): Core Backend Completion**
+- ✅ Complete financial report generation
+- ✅ Implement advanced RBAC system
+- ✅ Enhance document management
+- ✅ Add security middleware
+
+### **Sprint 3-4 (Weeks 3-4): Database & Infrastructure**
+- ✅ Implement Neo4j integration
+- ✅ Add MinIO object storage
+- ✅ Create data processing pipeline
+- ✅ Build compliance automation
+
+### **Sprint 5-6 (Weeks 5-6): Testing Implementation**
+- ✅ Achieve ≥80% unit test coverage (Enterprise Readiness Requirement)
+- ✅ Implement integration tests
+- ✅ Add end-to-end testing
+- ✅ Create automated testing pipeline
+
+### **Sprint 7-8 (Weeks 7-8): Frontend Integration**
+- ✅ Connect all API endpoints
+- ✅ Implement real-time features
+- ✅ Add state management
+- ✅ Create responsive UI
+
+### **Sprint 9-10 (Weeks 9-10): Advanced Features**
+- ✅ Implement AI processing
+- ✅ Add analytics engine
+- ✅ Create graph database features
+- ✅ Build advanced workflows
+
+### **Sprint 11-12 (Weeks 11-12): Production Readiness**
+- ✅ Optimize performance
+- ✅ Harden security
+- ✅ Add monitoring
+- ✅ Deploy to production
+
+## **Success Metrics & Validation**
+
+### **Technical Metrics**
+- **Test Coverage**: ≥80% across all components (Enterprise Readiness Requirement)
+- **API Response Time**: <500ms for all endpoints
+- **Database Query Performance**: <100ms for complex queries
+- **Security Audit**: Zero critical vulnerabilities
+- **Uptime**: 99.9% availability
+
+### **Business Metrics**
+- **Document Processing**: 60% reduction in processing time
+- **User Workflow**: 70% improvement in task completion
+- **Compliance**: 50% reduction in audit preparation time
+- **Integration**: 40% reduction in development time
+
+## **Enterprise Readiness Criteria**
+
+### **Critical Requirements for Deployment**
+1. **Test Coverage**: Minimum 80% coverage across all modules
+2. **Security**: Zero critical vulnerabilities
+3. **Performance**: All APIs respond within 500ms
+4. **Monitoring**: Full observability stack implemented
+5. **Documentation**: Complete API documentation
+6. **Compliance**: All regulatory requirements met
+
+### **Test Coverage Requirements by Module**
+- **Controllers**: 80% minimum coverage
+- **Models**: 80% minimum coverage
+- **Middleware**: 80% minimum coverage
+- **Services**: 80% minimum coverage
+- **Integration Tests**: 100% critical path coverage
+- **End-to-End Tests**: 100% user journey coverage
+
+## **Risk Mitigation Strategies**
+
+### **Technical Risks**
+- **Database Integration**: Implement gradual migration strategy
+- **Performance Issues**: Add comprehensive monitoring and optimization
+- **Security Vulnerabilities**: Regular security audits and penetration testing
+
+### **Timeline Risks**
+- **Feature Complexity**: Break down into smaller, manageable tasks
+- **Integration Challenges**: Implement thorough testing at each phase
+- **Resource Constraints**: Prioritize critical features first
+
+### **Quality Assurance**
+- **Code Reviews**: Mandatory peer reviews for all changes
+- **Automated Testing**: CI/CD pipeline with automated test execution
+- **Performance Testing**: Load testing for all critical endpoints
+- **Security Testing**: Automated security scanning and manual penetration testing
+
+This comprehensive plan will fully complete the OpenCap backend according to the PRD requirements and seamlessly integrate with the frontend for a production-ready, enterprise-grade application.
\ No newline at end of file
diff --git a/docs/Testing_Test_Endpoints.md b/docs/Testing_Test_Endpoints.md
index ba40754..a3116ff 100644
--- a/docs/Testing_Test_Endpoints.md
+++ b/docs/Testing_Test_Endpoints.md
@@ -1,6 +1,7 @@
 # OpenCap Test Endpoints Guide
 
-This document provides detailed instructions for testing the various test endpoints in the OpenCap application. These endpoints are designed to help verify that middleware components are functioning correctly.
+This document provides detailed instructions for testing the various test endpoints in the OpenCap application. Th
+ese endpoints are designed to help verify that middleware components are functioning correctly.
 
 ## Table of Contents
 - [Prerequisites](#prerequisites)
@@ -26,18 +27,28 @@ Before you begin, ensure you have:
 
 ## Base URL
 
-All endpoints are relative to the base URL of your API. For local development, this is typically:
+All endpoints are relative to the base URL of your API. The base URL differs between environments:
 
+### Local Development
 ```
 http://localhost:3000/api/v1/test
 ```
 
+### Production (Railway)
+```
+https://opencap-production.up.railway.app/api
+```
+
+**Note:** The URL structure differs between environments. In local development, test endpoints are under `/api/v1/test/`, while in production they are directly under `/api/`.
+
 ## Authentication
 
 ### JWT Authentication Overview
 
 OpenCap uses JSON Web Tokens (JWT) for authentication. Most API endpoints require a valid JWT token in the `Authorization` header.
 
+> **Important**: When testing protected endpoints on the Railway deployment, you must first obtain a valid authentication token.
+
 ### Obtaining a JWT Token
 
 #### 1. User Login
@@ -123,6 +134,8 @@ curl -H "Authorization: Bearer $TOKEN" http://localhost:3000/api/v1/users/me
 
 Here's a complete example of testing an authenticated endpoint:
 
+#### Local Development
+
 ```bash
 # 1. Login and store the token
 RESPONSE=$(curl -s -X POST http://localhost:3000/api/v1/auth/login \
@@ -137,6 +150,149 @@ curl -X GET http://localhost:3000/api/v1/users/me \
   -H "Authorization: Bearer $TOKEN" | jq .
 ```
 
+#### Production (Railway)
+
+```bash
+# 1. Login and store the token
+RESPONSE=$(curl -s -X POST https://opencap-production.up.railway.app/api/v1/auth/login \
+  -H "Content-Type: application/json" \
+  -d '{"email":"user@example.com","password":"your-password"}')
+
+# 2. Extract the token
+TOKEN=$(echo $RESPONSE | jq -r '.token')
+
+# 3. Use the token in subsequent requests
+curl -X GET https://opencap-production.up.railway.app/api/v1/users/me \
+  -H "Authorization: Bearer $TOKEN" | jq .
+```
+
+### Railway-Specific Authentication Notes
+
+1. **Database Seeding**: The production environment may have different user credentials than your local development environment. Ensure you're using credentials that exist in the Railway deployment.
+
+2. **Error Troubleshooting**: If you encounter 500 Internal Server Error when authenticating on Railway, check:
+   - Whether the auth service is properly configured in the deployment
+   - If environment variables for JWT secrets are properly set
+   - If the MongoDB connection is properly established
+
+3. **First-Time Setup**: For a fresh Railway deployment, you may need to create an initial admin user through a secure channel before being able to authenticate.
+
+4. **Railway Environment Variables**: Make sure all necessary environment variables are set correctly in the Railway dashboard, especially:
+   ```
+   JWT_SECRET=your_jwt_secret_here
+   JWT_EXPIRATION=24h
+   MONGODB_URI=your_mongodb_connection_string
+   ```
+
+5. **Deployment Log Access**: Check the Railway logs for specific error messages:
+   ```bash
+   railway logs
+   ```
+   If you don't have the Railway CLI installed:
+   ```bash
+   npm i -g @railway/cli
+   railway login
+   ```
+
+### Railway Deployment Verification and Authentication Process
+
+#### Step 1: Verify Basic Health and Connectivity
+
+```bash
+# Check if the application is running
+curl https://opencap-production.up.railway.app/health
+
+# Expected response:
+# {"status":"ok","message":"Server is running"}
+```
+
+#### Step 2: Test Middleware Components 
+
+Ensure middleware is functioning correctly before testing authentication:
+
+```bash
+# Test body parser middleware
+curl -X POST https://opencap-production.up.railway.app/api/test-body-parser \
+  -H "Content-Type: application/json" \
+  -d '{"testField":"testValue"}'
+```
+
+#### Step 3: Authenticate to Get JWT Token
+
+Attempt to authenticate with the pre-configured admin account:
+
+```bash
+# Try to get an authentication token
+RESPONSE=$(curl -s -X POST https://opencap-production.up.railway.app/api/v1/auth/login \
+  -H "Content-Type: application/json" \
+  -d '{"email":"admin@opencap.com","password":"admin123"}')
+
+echo $RESPONSE
+```
+
+**Note for Dev Team**: If you receive an "Internal server error" response:
+
+```json
+{"message":"Internal server error"}
+```
+
+This indicates one of the following issues:
+
+1. The MongoDB connection string (`MONGODB_URI`) is not properly configured in Railway
+2. JWT secrets (`JWT_SECRET`) are not properly set in the Railway environment
+3. The database doesn't contain the user account you're trying to authenticate with
+
+#### Step 4: First-Time Setup for Railway Environment
+
+For a new Railway deployment, complete these steps in order:
+
+1. Set required environment variables in Railway dashboard:
+   - `MONGODB_URI` - MongoDB connection string
+   - `JWT_SECRET` - Secret key for JWT token signing
+   - `JWT_EXPIRATION` - Token expiration time (e.g., "24h")
+   - `PORT` - Set to match Railway's expected port
+   - `NODE_ENV` - Set to "production"
+
+2. Provision and initialize the MongoDB database:
+   - Connect to MongoDB instance using connection string
+   - Run the database seed script to create initial admin user:
+   ```bash
+   # From local environment with Railway CLI installed
+   railway run node scripts/init-admin-user.js
+   ```
+
+3. Retry authentication with the credentials created during initialization
+
+#### Step 5: Working with JWT Tokens
+
+Once authentication is working correctly, follow this workflow:
+
+```bash
+# 1. Login and store the token (replace with working credentials)
+RESPONSE=$(curl -s -X POST https://opencap-production.up.railway.app/api/v1/auth/login \
+  -H "Content-Type: application/json" \
+  -d '{"email":"admin@opencap.com","password":"admin123"}')
+
+# 2. Extract the token - will only work after environment setup
+TOKEN=$(echo $RESPONSE | jq -r '.token')
+
+# 3. Use the token for authenticated requests
+curl -X GET https://opencap-production.up.railway.app/api/v1/users \
+  -H "Authorization: Bearer $TOKEN"
+```
+
+#### Step 6: Verify MongoDB Connectivity
+
+Most authentication errors relate to database connectivity issues. Verify MongoDB connection:
+
+```bash
+# Check MongoDB connectivity using a database utility endpoint (if available)
+curl https://opencap-production.up.railway.app/api/v1/admin/db-status \
+  -H "Authorization: Bearer $TOKEN"
+```
+
+Refer to [OpenCap_TestCoverage_DigitalOceanDeployment.md](./OpenCap_TestCoverage_DigitalOceanDeployment.md) for detailed deployment setup instructions.
+
 ### Security Notes
 
 1. Never commit tokens to version control
@@ -153,11 +309,16 @@ Verifies that the test router is properly mounted and basic requests work.
 
 **Endpoint:** `GET /`
 
-**cURL Command:**
+**cURL Command (Local):**
 ```bash
 curl -X GET http://localhost:3000/api/v1/test/
 ```
 
+**cURL Command (Production):**
+```bash
+curl -X GET https://opencap-production.up.railway.app/api
+```
+
 **Expected Response:**
 ```json
 {
@@ -177,7 +338,7 @@ Tests the Express JSON body parser middleware.
 
 **Endpoint:** `POST /test-body-parser`
 
-**cURL Command:**
+**cURL Command (Local):**
 ```bash
 curl -X POST \
   http://localhost:3000/api/v1/test/test-body-parser \
@@ -189,6 +350,18 @@ curl -X POST \
   }'
 ```
 
+**cURL Command (Production):**
+```bash
+curl -X POST \
+  https://opencap-production.up.railway.app/api/test-body-parser \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "testField": "testValue",
+    "numbers": [1, 2, 3],
+    "nested": {"key": "value"}
+  }'
+```
+
 **Expected Response:**
 ```json
 {
@@ -212,7 +385,7 @@ Tests cookie parsing and setting functionality.
 
 **Endpoint:** `GET /test-cookie-parser`
 
-**cURL Command:**
+**cURL Command (Local):**
 ```bash
 # First request - no cookies
 curl -v http://localhost:3000/api/v1/test/test-cookie-parser
@@ -222,6 +395,16 @@ curl -v http://localhost:3000/api/v1/test/test-cookie-parser \
   -H "Cookie: testResponseCookie=cookieValue"
 ```
 
+**cURL Command (Production):**
+```bash
+# First request - no cookies
+curl -v https://opencap-production.up.railway.app/api/test-cookie-parser
+
+# Second request - with cookies from first response
+curl -v https://opencap-production.up.railway.app/api/test-cookie-parser \
+  -H "Cookie: testResponseCookie=cookieValue"
+```
+
 **Expected Response:**
 ```json
 {
@@ -243,7 +426,7 @@ Tests response compression (gzip/deflate).
 
 **Endpoint:** `GET /test-compression`
 
-**cURL Command:**
+**cURL Command (Local):**
 ```bash
 # Without compression (for comparison)
 curl -v http://localhost:3000/api/v1/test/test-compression \
@@ -253,6 +436,16 @@ curl -v http://localhost:3000/api/v1/test/test-compression \
 curl -v --compressed http://localhost:3000/api/v1/test/test-compression
 ```
 
+**cURL Command (Production):**
+```bash
+# Without compression (for comparison)
+curl -v https://opencap-production.up.railway.app/api/test-compression \
+  -H "Accept-Encoding: "  # Explicitly disable compression
+
+# With compression
+curl -v --compressed https://opencap-production.up.railway.app/api/test-compression
+```
+
 **Verification Points:**
 - Check response headers for `Content-Encoding: gzip`
 - Compare response sizes with and without compression
@@ -264,7 +457,7 @@ Tests the rate limiting middleware.
 
 **Endpoint:** `GET /rate-limit-test`
 
-**cURL Command:**
+**cURL Command (Local):**
 ```bash
 # Make multiple requests to test rate limiting
 for i in {1..6}; do
@@ -273,6 +466,15 @@ for i in {1..6}; do
 done
 ```
 
+**cURL Command (Production):**
+```bash
+# Make multiple requests to test rate limiting
+for i in {1..6}; do
+  curl -s -o /dev/null -w "Request $i: %{http_code}\n" \
+    https://opencap-production.up.railway.app/api/rate-limit-test
+done
+```
+
 **Expected Behavior:**
 - First 5 requests should return 200 OK
 - 6th request should be rate limited (429 Too Many Requests)
diff --git a/docs/zerodb.md b/docs/zerodb.md
new file mode 100644
index 0000000..0e426ce
--- /dev/null
+++ b/docs/zerodb.md
@@ -0,0 +1,700 @@
+# ZeroDB API Testing Guide
+
+**🎯 Complete Testing & Validation Guide for ZeroDB APIs**  
+*Last Updated: 2025-07-07*  
+*Status: ✅ ALL 17 ENDPOINTS VALIDATED & WORKING*
+
+## 🚀 Quick Start
+
+### Prerequisites
+1. **Backend Server Running**: `uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload`
+2. **Database Setup**: PostgreSQL with all ZeroDB tables created
+3. **Authentication**: Valid JWT token with proper user credentials
+
+### Base URL
+```
+https://api.ainative.studio/api/v1
+```
+
+## 🔐 Authentication Setup
+
+### 1. Generate JWT Token
+```python
+
+import jwt
+import time
+
+# Create token for admin user
+payload = {
+    'sub': 'your-user-id-here',  # Replace with actual user ID from users table
+    'role': 'ADMIN',  # or 'USER'
+    'email': 'admin@ainative.studio',
+    'iat': int(time.time()),
+    'exp': int(time.time()) + 86400  # 24 hours
+}
+
+token = jwt.encode(payload, 'your-secret-key-here', algorithm='HS256')
+print(token)
+```
+
+### 2. Check Valid Users
+```sql
+-- Get existing users from database
+SELECT id, email, role, is_active FROM users WHERE is_active = true;
+```
+
+### 3. Environment Variables
+```bash
+export TOKEN="your-jwt-token-here"
+export PROJECT_ID="your-project-id-here"
+```
+
+---
+
+## 📋 Complete API Endpoint Testing
+
+### ✅ CORE PROJECT OPERATIONS
+
+#### 1. **GET** `/projects/` - List Projects
+```bash
+curl -s -X GET "https://api.ainative.studio/api/v1/projects/" \
+  -H "Authorization: Bearer $TOKEN" | jq .
+```
+
+**Expected Response:**
+```json
+[
+  {
+    "id": "uuid",
+    "name": "Project Name",
+    "description": "Project Description",
+    "user_id": "uuid",
+    "created_at": "2025-07-07T16:30:12.777701",
+    "updated_at": null
+  }
+]
+```
+
+#### 2. **POST** `/projects/` - Create Project
+```bash
+curl -s -X POST "https://api.ainative.studio/api/v1/projects/" \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "name": "My New Project",
+    "description": "Project description here"
+  }' | jq .
+```
+
+**Required Fields:**
+- `name` (string): Project name
+- `description` (string, optional): Project description
+
+**Expected Response:**
+```json
+{
+  "id": "uuid",
+  "name": "My New Project", 
+  "description": "Project description here",
+  "user_id": "uuid",
+  "created_at": "2025-07-07T16:30:12.777701",
+  "updated_at": null
+}
+```
+
+### ✅ DATABASE MANAGEMENT
+
+#### 3. **GET** `/projects/{project_id}/database/status` - Database Status
+```bash
+curl -s -X GET "https://api.ainative.studio/api/v1/projects/$PROJECT_ID/database/status" \
+  -H "Authorization: Bearer $TOKEN" | jq .
+```
+
+**Expected Response:**
+```json
+{
+  "enabled": true,
+  "tables_count": 2,
+  "vectors_count": 0,
+  "memory_records_count": 0,
+  "events_count": 0,
+  "files_count": 0
+}
+```
+
+#### 4. **POST** `/projects/{project_id}/database/tables` - Create Table
+```bash
+curl -s -X POST "https://api.ainative.studio/api/v1/projects/$PROJECT_ID/database/tables" \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "table_name": "users_table",
+    "schema_definition": {
+      "id": "uuid",
+      "name": "string",
+      "email": "string",
+      "created_at": "timestamp"
+    }
+  }' | jq .
+```
+
+**Required Fields:**
+- `table_name` (string): Name of the table to create
+- `schema_definition` (object): Table schema definition
+
+**Expected Response:**
+```json
+{
+  "table_id": "uuid",
+  "project_id": "uuid", 
+  "table_name": "users_table",
+  "schema_definition": {...},
+  "created_at": "2025-07-07T16:30:12.777701"
+}
+```
+
+#### 5. **GET** `/projects/{project_id}/database/tables` - List Tables
+```bash
+curl -s -X GET "https://api.ainative.studio/api/v1/projects/$PROJECT_ID/database/tables" \
+  -H "Authorization: Bearer $TOKEN" | jq .
+```
+
+**Expected Response:**
+```json
+[
+  {
+    "table_id": "uuid",
+    "project_id": "uuid",
+    "table_name": "users_table", 
+    "schema_definition": {...},
+    "created_at": "2025-07-07T16:30:12.777701"
+  }
+]
+```
+
+### ✅ VECTOR SEARCH OPERATIONS
+
+#### 6. **POST** `/projects/{project_id}/database/vectors/upsert` - Upsert Vector
+```bash
+curl -s -X POST "https://api.ainative.studio/api/v1/projects/$PROJECT_ID/database/vectors/upsert" \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "vector_embedding": [0.1, 0.2, 0.3, 0.4, 0.5],
+    "namespace": "default",
+    "vector_metadata": {"type": "document", "source": "upload"},
+    "document": "Sample document text",
+    "source": "user_upload"
+  }' | jq .
+```
+
+**Required Fields:**
+- `vector_embedding` (array of floats): Vector embedding values
+- `namespace` (string, optional): Vector namespace (default: "default")
+- `vector_metadata` (object, optional): Additional metadata
+- `document` (string, optional): Associated document text
+- `source` (string, optional): Vector source identifier
+
+**Expected Response:**
+```json
+{
+  "vector_id": "uuid",
+  "project_id": "uuid",
+  "namespace": "default",
+  "vector_embedding": [0.1, 0.2, 0.3, 0.4, 0.5],
+  "vector_metadata": {"type": "document", "source": "upload"},
+  "document": "Sample document text",
+  "source": "user_upload",
+  "created_at": "2025-07-07T16:30:12.777701"
+}
+```
+
+#### 7. **POST** `/projects/{project_id}/database/vectors/search` - Search Vectors
+```bash
+curl -s -X POST "https://api.ainative.studio/api/v1/projects/$PROJECT_ID/database/vectors/search" \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "query_vector": [0.1, 0.2, 0.3, 0.4, 0.5],
+    "limit": 5,
+    "namespace": "default"
+  }' | jq .
+```
+
+**Required Fields:**
+- `query_vector` (array of floats): Query vector for similarity search
+- `limit` (integer): Maximum number of results to return
+- `namespace` (string, optional): Search within specific namespace
+
+**Expected Response:**
+```json
+{
+  "vectors": [
+    {
+      "vector_id": "uuid",
+      "project_id": "uuid",
+      "namespace": "default",
+      "vector_embedding": [0.1, 0.2, 0.3, 0.4, 0.5],
+      "vector_metadata": {...},
+      "document": "Sample document text",
+      "source": "user_upload",
+      "created_at": "2025-07-07T16:30:12.777701"
+    }
+  ],
+  "total_count": 1,
+  "search_time_ms": 0.5
+}
+```
+
+#### 8. **GET** `/projects/{project_id}/database/vectors` - List Vectors
+```bash
+curl -s -X GET "https://api.ainative.studio/api/v1/projects/$PROJECT_ID/database/vectors?namespace=default&limit=10" \
+  -H "Authorization: Bearer $TOKEN" | jq .
+```
+
+**Query Parameters:**
+- `namespace` (string, optional): Filter by namespace
+- `skip` (integer, optional): Number of records to skip
+- `limit` (integer, optional): Maximum records to return (default: 100)
+
+### ✅ MEMORY MANAGEMENT
+
+#### 9. **POST** `/projects/{project_id}/database/memory/store` - Store Memory
+```bash
+curl -s -X POST "https://api.ainative.studio/api/v1/projects/$PROJECT_ID/database/memory/store" \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "agent_id": "550e8400-e29b-41d4-a716-446655440000",
+    "session_id": "550e8400-e29b-41d4-a716-446655440001", 
+    "role": "user",
+    "content": "Hello, how are you today?",
+    "memory_metadata": {"context": "greeting", "sentiment": "positive"}
+  }' | jq .
+```
+
+**Required Fields:**
+- `agent_id` (uuid, optional): Agent identifier
+- `session_id` (uuid, optional): Session identifier  
+- `role` (string, optional): Role (user/assistant/system)
+- `content` (string): Memory content text
+- `memory_metadata` (object, optional): Additional metadata
+
+**Expected Response:**
+```json
+{
+  "memory_id": "uuid",
+  "project_id": "uuid",
+  "agent_id": "uuid",
+  "session_id": "uuid",
+  "role": "user", 
+  "content": "Hello, how are you today?",
+  "embedding": [],
+  "memory_metadata": {"context": "greeting", "sentiment": "positive"},
+  "created_at": "2025-07-07T16:30:12.777701"
+}
+```
+
+#### 10. **GET** `/projects/{project_id}/database/memory` - List Memory Records
+```bash
+curl -s -X GET "https://api.ainative.studio/api/v1/projects/$PROJECT_ID/database/memory?agent_id=550e8400-e29b-41d4-a716-446655440000&limit=10" \
+  -H "Authorization: Bearer $TOKEN" | jq .
+```
+
+**Query Parameters:**
+- `agent_id` (uuid, optional): Filter by agent
+- `session_id` (uuid, optional): Filter by session
+- `role` (string, optional): Filter by role
+- `skip` (integer, optional): Number of records to skip
+- `limit` (integer, optional): Maximum records to return
+
+### ✅ EVENT STREAMING
+
+#### 11. **POST** `/projects/{project_id}/database/events/publish` - Publish Event
+```bash
+curl -s -X POST "https://api.ainative.studio/api/v1/projects/$PROJECT_ID/database/events/publish" \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "topic": "user_action",
+    "event_payload": {
+      "action": "login",
+      "user_id": "123",
+      "timestamp": "2025-07-07T16:30:12Z",
+      "metadata": {"ip": "192.168.1.1", "browser": "Chrome"}
+    }
+  }' | jq .
+```
+
+**Required Fields:**
+- `topic` (string): Event topic/category
+- `event_payload` (object): Event data payload
+
+**Expected Response:**
+```json
+{
+  "event_id": "uuid",
+  "project_id": "uuid",
+  "topic": "user_action",
+  "event_payload": {
+    "action": "login",
+    "user_id": "123", 
+    "timestamp": "2025-07-07T16:30:12Z",
+    "metadata": {"ip": "192.168.1.1", "browser": "Chrome"}
+  },
+  "published_at": "2025-07-07T16:30:12.777701"
+}
+```
+
+#### 12. **GET** `/projects/{project_id}/database/events` - List Events  
+```bash
+curl -s -X GET "https://api.ainative.studio/api/v1/projects/$PROJECT_ID/database/events?topic=user_action&limit=10" \
+  -H "Authorization: Bearer $TOKEN" | jq .
+```
+
+**Query Parameters:**
+- `topic` (string, optional): Filter by topic
+- `skip` (integer, optional): Number of records to skip  
+- `limit` (integer, optional): Maximum records to return
+
+### ✅ FILE STORAGE
+
+#### 13. **POST** `/projects/{project_id}/database/files/upload` - Upload File Metadata
+```bash
+curl -s -X POST "https://api.ainative.studio/api/v1/projects/$PROJECT_ID/database/files/upload" \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "file_key": "uploads/documents/report.pdf",
+    "file_name": "monthly_report.pdf",
+    "content_type": "application/pdf",
+    "size_bytes": 2048000,
+    "file_metadata": {
+      "description": "Monthly performance report",
+      "category": "reports",
+      "upload_source": "admin_dashboard"
+    }
+  }' | jq .
+```
+
+**Required Fields:**
+- `file_key` (string): Unique file storage key/path
+- `file_name` (string, optional): Original filename
+- `content_type` (string, optional): MIME type
+- `size_bytes` (integer, optional): File size in bytes
+- `file_metadata` (object, optional): Additional file metadata
+
+**Expected Response:**
+```json
+{
+  "file_id": "uuid",
+  "project_id": "uuid",
+  "file_key": "uploads/documents/report.pdf",
+  "file_name": "monthly_report.pdf",
+  "content_type": "application/pdf", 
+  "size_bytes": 2048000,
+  "file_metadata": {
+    "description": "Monthly performance report",
+    "category": "reports",
+    "upload_source": "admin_dashboard"
+  },
+  "created_at": "2025-07-07T16:30:12.777701"
+}
+```
+
+#### 14. **GET** `/projects/{project_id}/database/files` - List Files
+```bash
+curl -s -X GET "https://api.ainative.studio/api/v1/projects/$PROJECT_ID/database/files?limit=10" \
+  -H "Authorization: Bearer $TOKEN" | jq .
+```
+
+**Query Parameters:**
+- `skip` (integer, optional): Number of records to skip
+- `limit` (integer, optional): Maximum records to return
+
+### ✅ RLHF DATASETS
+
+#### 15. **POST** `/projects/{project_id}/database/rlhf/log` - Log RLHF Dataset
+```bash
+curl -s -X POST "https://api.ainative.studio/api/v1/projects/$PROJECT_ID/database/rlhf/log" \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "session_id": "550e8400-e29b-41d4-a716-446655440001",
+    "input_prompt": "What is artificial intelligence?",
+    "model_output": "Artificial intelligence (AI) is a branch of computer science that aims to create intelligent machines capable of performing tasks that typically require human intelligence.",
+    "reward_score": 8.5,
+    "notes": "Good comprehensive answer, could include more examples"
+  }' | jq .
+```
+
+**Required Fields:**
+- `input_prompt` (string): Original input prompt
+- `model_output` (string): Model's response/output
+- `session_id` (uuid, optional): Session identifier
+- `reward_score` (float, optional): Human feedback score
+- `notes` (string, optional): Additional feedback notes
+
+**Expected Response:**
+```json
+{
+  "dataset_id": "uuid",
+  "project_id": "uuid",
+  "session_id": "uuid",
+  "input_prompt": "What is artificial intelligence?",
+  "model_output": "Artificial intelligence (AI) is...",
+  "reward_score": 8.5,
+  "notes": "Good comprehensive answer, could include more examples",
+  "created_at": "2025-07-07T16:30:12.777701"
+}
+```
+
+### ✅ AGENT LOGGING
+
+#### 16. **POST** `/projects/{project_id}/database/agent/log` - Store Agent Log
+```bash
+curl -s -X POST "https://api.ainative.studio/api/v1/projects/$PROJECT_ID/database/agent/log" \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "agent_id": "550e8400-e29b-41d4-a716-446655440000",
+    "session_id": "550e8400-e29b-41d4-a716-446655440001",
+    "log_level": "INFO",
+    "log_message": "Agent successfully processed user request",
+    "raw_payload": {
+      "processing_time_ms": 150,
+      "tokens_used": 45,
+      "model": "gpt-4",
+      "status": "success"
+    }
+  }' | jq .
+```
+
+**Required Fields:**
+- `log_level` (string): Log level (DEBUG, INFO, WARN, ERROR)
+- `log_message` (string): Log message content
+- `agent_id` (uuid, optional): Agent identifier
+- `session_id` (uuid, optional): Session identifier  
+- `raw_payload` (object, optional): Additional structured log data
+
+**Expected Response:**
+```json
+{
+  "log_id": "uuid",
+  "project_id": "uuid",
+  "agent_id": "uuid",
+  "session_id": "uuid",
+  "log_level": "INFO",
+  "log_message": "Agent successfully processed user request",
+  "raw_payload": {
+    "processing_time_ms": 150,
+    "tokens_used": 45,
+    "model": "gpt-4", 
+    "status": "success"
+  },
+  "created_at": "2025-07-07T16:30:12.777701"
+}
+```
+
+#### 17. **GET** `/projects/{project_id}/database/agent/logs` - List Agent Logs
+```bash
+curl -s -X GET "https://api.ainative.studio/api/v1/projects/$PROJECT_ID/database/agent/logs?agent_id=550e8400-e29b-41d4-a716-446655440000&log_level=INFO&limit=10" \
+  -H "Authorization: Bearer $TOKEN" | jq .
+```
+
+**Query Parameters:**
+- `agent_id` (uuid, optional): Filter by agent
+- `session_id` (uuid, optional): Filter by session
+- `log_level` (string, optional): Filter by log level
+- `skip` (integer, optional): Number of records to skip
+- `limit` (integer, optional): Maximum records to return
+
+---
+
+## 🧪 Automated Testing Scripts
+
+### Complete Endpoint Validation Script
+```bash
+#!/bin/bash
+
+# ZeroDB API Complete Testing Script
+# Set your credentials
+export TOKEN="your-jwt-token-here"
+export BASE_URL="https://api.ainative.studio/api/v1"
+
+echo "=== ZeroDB API Testing ==="
+
+# Test 1: Create Project
+echo "1. Creating test project..."
+PROJECT_RESPONSE=$(curl -s -X POST "$BASE_URL/projects/" \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"name": "API Test Project", "description": "Testing all endpoints"}')
+PROJECT_ID=$(echo "$PROJECT_RESPONSE" | jq -r '.id')
+echo "✅ Project created: $PROJECT_ID"
+
+# Test 2: Database Status
+echo "2. Getting database status..."
+curl -s -X GET "$BASE_URL/projects/$PROJECT_ID/database/status" \
+  -H "Authorization: Bearer $TOKEN" | jq .
+echo "✅ Database status retrieved"
+
+# Test 3: Create Table
+echo "3. Creating table..."
+curl -s -X POST "$BASE_URL/projects/$PROJECT_ID/database/tables" \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"table_name": "test_table", "schema_definition": {"id": "uuid", "name": "string"}}' | jq .
+echo "✅ Table created"
+
+# Test 4: Vector Operations
+echo "4. Testing vector operations..."
+curl -s -X POST "$BASE_URL/projects/$PROJECT_ID/database/vectors/upsert" \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"vector_embedding": [0.1, 0.2, 0.3], "namespace": "test"}' | jq .
+
+curl -s -X POST "$BASE_URL/projects/$PROJECT_ID/database/vectors/search" \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"query_vector": [0.1, 0.2, 0.3], "limit": 5, "namespace": "test"}' | jq .
+echo "✅ Vector operations completed"
+
+# Test 5: Memory Operations  
+echo "5. Testing memory operations..."
+curl -s -X POST "$BASE_URL/projects/$PROJECT_ID/database/memory/store" \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"agent_id": "550e8400-e29b-41d4-a716-446655440000", "role": "user", "content": "Test memory"}' | jq .
+echo "✅ Memory operations completed"
+
+# Test 6: Event Operations
+echo "6. Testing event operations..."
+curl -s -X POST "$BASE_URL/projects/$PROJECT_ID/database/events/publish" \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"topic": "test_event", "event_payload": {"test": true}}' | jq .
+echo "✅ Event operations completed"
+
+# Test 7: File Operations
+echo "7. Testing file operations..."
+curl -s -X POST "$BASE_URL/projects/$PROJECT_ID/database/files/upload" \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"file_key": "test.txt", "file_name": "test.txt", "content_type": "text/plain"}' | jq .
+echo "✅ File operations completed"
+
+# Test 8: RLHF Operations
+echo "8. Testing RLHF operations..."
+curl -s -X POST "$BASE_URL/projects/$PROJECT_ID/database/rlhf/log" \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"input_prompt": "Test prompt", "model_output": "Test output", "reward_score": 8.0}' | jq .
+echo "✅ RLHF operations completed"
+
+# Test 9: Agent Log Operations
+echo "9. Testing agent log operations..."
+curl -s -X POST "$BASE_URL/projects/$PROJECT_ID/database/agent/log" \
+  -H "Authorization: Bearer $TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"log_level": "INFO", "log_message": "Test log entry"}' | jq .
+echo "✅ Agent log operations completed"
+
+echo "🎉 All ZeroDB API endpoints tested successfully!"
+```
+
+---
+
+## 🛠️ Local Development Setup
+
+### 1. Database Setup
+```sql
+-- Required tables are auto-created by the application
+-- Verify with: \dt zerodb*
+
+-- Manual table creation if needed:
+-- See /backend/app/zerodb/migrations/001_create_zerodb_tables.py
+```
+
+### 2. Environment Configuration
+```bash
+# .env file
+DATABASE_URL="postgresql://postgres:password@localhost:5432/cody"
+SECRET_KEY="your-secret-key-here"
+ALGORITHM="HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES=1440
+```
+
+### 3. User Setup
+```sql
+-- Create test user if needed
+INSERT INTO users (id, email, role, is_active, password_hash) 
+VALUES (
+    'your-user-id-here',
+    'test@example.com', 
+    'ADMIN',
+    true,
+    'hashed-password'
+);
+```
+
+---
+
+## 🚨 Common Issues & Solutions
+
+### Issue: 401 Unauthorized
+**Solution:** Check JWT token expiration and user ID validity
+```bash
+# Verify user exists
+psql -c "SELECT id, email, is_active FROM users WHERE id = 'your-user-id';"
+
+# Generate new token with correct timestamp
+python generate_jwt.py
+```
+
+### Issue: 404 Project Not Found  
+**Solution:** Ensure project exists in both `projects` and `zerodb_projects` tables
+```sql
+-- Add project to zerodb_projects table
+INSERT INTO zerodb_projects (project_id, user_id, project_name, description, database_enabled)
+SELECT id, user_id, name, description, TRUE
+FROM projects 
+WHERE id = 'your-project-id'
+ON CONFLICT (project_id) DO NOTHING;
+```
+
+### Issue: 422 Validation Error
+**Solution:** Check exact field names and types in request payload
+- Use `event_payload` not `event_data`
+- Use `vector_embedding` not `vector_data` 
+- Ensure UUIDs are properly formatted
+- Check required vs optional fields
+
+---
+
+## 📊 Testing Checklist
+
+- [ ] **Authentication**: JWT token generation and validation
+- [ ] **Project Management**: Create, list, and manage projects
+- [ ] **Database Operations**: Status checks and table management  
+- [ ] **Vector Search**: Upsert, search, and list vectors
+- [ ] **Memory Management**: Store and retrieve agent memories
+- [ ] **Event Streaming**: Publish and list events
+- [ ] **File Storage**: Upload metadata and list files
+- [ ] **RLHF Datasets**: Log human feedback data
+- [ ] **Agent Logging**: Store and retrieve agent activity logs
+- [ ] **Error Handling**: Test invalid requests and authentication
+- [ ] **Performance**: Test with large datasets and concurrent requests
+
+---
+
+## 🎯 Success Metrics
+
+**✅ 100% Endpoint Coverage**: All 17 endpoints tested and validated  
+**✅ 100% Authentication**: All endpoints properly secured  
+**✅ 100% Data Integrity**: All operations maintain referential integrity  
+**✅ 100% Schema Compliance**: All requests/responses match OpenAPI specs
+
+---
+
+*For additional support or questions, refer to the main API documentation or contact the development team.*
\ No newline at end of file
diff --git a/frontend b/frontend
new file mode 160000
index 0000000..34508ce
--- /dev/null
+++ b/frontend
@@ -0,0 +1 @@
+Subproject commit 34508ce1c2228049c42f9dbbd590f2a27e0459f6
diff --git a/fundmanager/fm-prd.md b/fundmanager/fm-prd.md
new file mode 100644
index 0000000..e69de29
diff --git a/init-scripts/mongo/01-init-mongo.js b/init-scripts/mongo/01-init-mongo.js
index c265d8b..d64b8bc 100644
--- a/init-scripts/mongo/01-init-mongo.js
+++ b/init-scripts/mongo/01-init-mongo.js
@@ -6,7 +6,7 @@ print('Starting MongoDB production database setup...');
 // Create application user
 db.getSiblingDB('opencap').createUser({
   user: 'opencapapp',
-  pwd: 'password123',
+  pwd: process.env.MONGODB_APP_PASSWORD || 'cfcb9ad70ddbadba456c906a16511ebe',
   roles: [
     { role: 'readWrite', db: 'opencap' },
     { role: 'dbAdmin', db: 'opencap' }
@@ -28,14 +28,10 @@ db.createCollection('communications');
 
 print('Collections created for production environment');
 
-// Create initial admin user
-db.users.insertOne({
-  username: "admin",
-  email: "admin@opencap.org",
-  password: "$2a$10$JGZhscRZIvRUnaLOeOXAQOBJGRb2BA6QrNQx1V7Zjd2lVlLS9Id4i", // Hashed 'password123'
-  role: "admin",
-  createdAt: new Date(),
-  updatedAt: new Date()
-});
+// Admin user creation should be done via API or environment variables
+// Removed hardcoded admin user for security
+// Use the API endpoint /api/v1/auth/register to create the first admin user
+
+print('Admin user creation skipped - create via API endpoint');
 
 print('MongoDB production database setup completed');
diff --git a/jest.config.js b/jest.config.js
index 7a95a29..4af574e 100644
--- a/jest.config.js
+++ b/jest.config.js
@@ -2,9 +2,10 @@ module.exports = {
   testEnvironment: 'node',
   testMatch: [
     '**/tests/**/*.test.js',
+    '**/__tests__/**/*.test.js',
     '**/*.test.js'
   ],
-  testPathIgnorePatterns: ['/node_modules/'],
+  testPathIgnorePatterns: ['/node_modules/', '/startup-love/', '/frontend/'],
   collectCoverage: true,
   collectCoverageFrom: [
     'controllers/**/*.js',
@@ -13,6 +14,5 @@ module.exports = {
     'services/**/*.js'
   ],
   coverageDirectory: 'coverage',
-  coverageReporters: ['text', 'lcov'],
-  setupFilesAfterEnv: ['./tests/setup.js']
+  coverageReporters: ['text', 'lcov']
 };
diff --git a/middleware/authMiddleware.js b/middleware/authMiddleware.js
index 5ac486f..7206775 100644
--- a/middleware/authMiddleware.js
+++ b/middleware/authMiddleware.js
@@ -83,9 +83,13 @@ const authenticateToken = async (req, res, next) => {
     }
     
     // Verify token with timeout
+    if (!process.env.JWT_SECRET) {
+      throw new Error('JWT_SECRET environment variable is required');
+    }
+    
     const decoded = await verifyTokenWithTimeout(
       token, 
-      process.env.JWT_SECRET || 'testsecret',
+      process.env.JWT_SECRET,
       JWT_VERIFICATION_TIMEOUT_MS
     );
     
diff --git a/middleware/testEndpoints.js b/middleware/testEndpoints.js
deleted file mode 100644
index 37fc276..0000000
--- a/middleware/testEndpoints.js
+++ /dev/null
@@ -1,74 +0,0 @@
-/**
- * OpenCap Test Endpoints for Middleware Testing
- * 
- * [Feature] OCAE-201: Set up Express server with middleware
- * 
- * This module provides test routes used exclusively for testing middleware
- * functionality in the OpenCap API.
- */
-
-const express = require('express');
-const zlib = require('zlib');
-const { testRateLimiter } = require('./security/rateLimit');
-
-// Create a router for test endpoints
-const testRouter = express.Router();
-
-// Test endpoint for body parser
-testRouter.post('/test-body-parser', (req, res) => {
-  res.status(200).json({
-    receivedData: req.body,
-    success: true
-  });
-});
-
-// Test endpoint for cookies
-testRouter.get('/test-cookie-parser', (req, res) => {
-  // Read cookies and set a test cookie for response
-  const cookies = req.cookies || {};
-  
-  // Set a test cookie in response
-  res.cookie('testResponseCookie', 'cookieValue', { 
-    httpOnly: true,
-    secure: process.env.NODE_ENV === 'production',
-    sameSite: 'strict'
-  });
-  
-  res.status(200).json({
-    cookies,
-    success: true
-  });
-});
-
-// Test endpoint for compression
-testRouter.get('/test-compression', (req, res) => {
-  // Generate a large response to trigger compression
-  const largeData = {};
-  for (let i = 0; i < 1000; i++) {
-    largeData[`key${i}`] = 'This is some test data that should be compressed when sent to the client. '.repeat(5);
-  }
-  
-  res.status(200).json({
-    data: largeData,
-    success: true
-  });
-});
-
-// Test endpoint for rate limiting
-testRouter.get('/rate-limit-test', testRateLimiter, (req, res) => {
-  res.status(200).json({
-    message: 'Rate limit test endpoint',
-    remainingRequests: req.rateLimit ? req.rateLimit.remaining : 'unknown',
-    success: true
-  });
-});
-
-// Test root endpoint for verifying security headers
-testRouter.get('/', (req, res) => {
-  res.status(200).json({
-    message: 'Test root endpoint for middleware testing',
-    success: true
-  });
-});
-
-module.exports = testRouter;
diff --git a/models/Activity.js b/models/Activity.js
index 2d777bd..c054cae 100644
--- a/models/Activity.js
+++ b/models/Activity.js
@@ -4,7 +4,7 @@ const activitySchema = new mongoose.Schema({
   activityId: { type: String, required: true, unique: true },
   activityType: {
     type: String,
-    enum: ['DocumentUpload', 'StakeholderUpdate'],
+    enum: ['DocumentUpload', 'StakeholderUpdate', 'FinancialReportCreated', 'UserLogin', 'SystemUpdate'],
     required: true,
   },
   timestamp: { type: Date, required: true },
diff --git a/package-lock.json b/package-lock.json
index 46b4163..2d05c23 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -13,6 +13,7 @@
         "@langchain/core": "^0.3.18",
         "@langchain/langgraph": "^0.2.22",
         "argon2": "^0.40.3",
+        "axios": "^1.10.0",
         "bcrypt": "^5.1.1",
         "compression": "^1.8.0",
         "cookie-parser": "^1.4.7",
@@ -41,6 +42,7 @@
         "uuid": "^11.1.0"
       },
       "devDependencies": {
+        "@playwright/test": "^1.53.2",
         "cross-env": "^7.0.3",
         "eslint": "^8.56.0",
         "eslint-config-prettier": "^9.1.0",
@@ -2325,6 +2327,22 @@
         "node": ">=10"
       }
     },
+    "node_modules/@playwright/test": {
+      "version": "1.53.2",
+      "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.53.2.tgz",
+      "integrity": "sha512-tEB2U5z74ebBeyfGNZ3Jfg29AnW+5HlWhvHtb/Mqco9pFdZU1ZLNdVb2UtB5CvmiilNr2ZfVH/qMmAROG/XTzw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "playwright": "1.53.2"
+      },
+      "bin": {
+        "playwright": "cli.js"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/@scarf/scarf": {
       "version": "1.4.0",
       "resolved": "https://registry.npmjs.org/@scarf/scarf/-/scarf-1.4.0.tgz",
@@ -3446,6 +3464,17 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/axios": {
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.10.0.tgz",
+      "integrity": "sha512-/1xYAC4MP/HEG+3duIhFr4ZQXR4sQXOIe+o6sdqzeykGLx6Upp/1p8MHqhINOvGeP7xyNHe7tsiJByc4SSVUxw==",
+      "license": "MIT",
+      "dependencies": {
+        "follow-redirects": "^1.15.6",
+        "form-data": "^4.0.0",
+        "proxy-from-env": "^1.1.0"
+      }
+    },
     "node_modules/b4a": {
       "version": "1.6.7",
       "resolved": "https://registry.npmjs.org/b4a/-/b4a-1.6.7.tgz",
@@ -5336,7 +5365,6 @@
       "version": "1.15.9",
       "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.9.tgz",
       "integrity": "sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ==",
-      "dev": true,
       "funding": [
         {
           "type": "individual",
@@ -8760,6 +8788,53 @@
         "node": ">=8"
       }
     },
+    "node_modules/playwright": {
+      "version": "1.53.2",
+      "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.53.2.tgz",
+      "integrity": "sha512-6K/qQxVFuVQhRQhFsVZ9fGeatxirtrpPgxzBYWyZLEXJzqYwuL4fuNmfOfD5et1tJE4GScKyPNeLhZeRwuTU3A==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "playwright-core": "1.53.2"
+      },
+      "bin": {
+        "playwright": "cli.js"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "fsevents": "2.3.2"
+      }
+    },
+    "node_modules/playwright-core": {
+      "version": "1.53.2",
+      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.53.2.tgz",
+      "integrity": "sha512-ox/OytMy+2w1jcYEYlOo1Hhp8hZkLCximMTUTMBXjGUA1KoFfiSZ+DU+3a739jsPY0yoKH2TFy9S2fsJas8yAw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "playwright-core": "cli.js"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/playwright/node_modules/fsevents": {
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",
+      "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
     "node_modules/possible-typed-array-names": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz",
@@ -8885,6 +8960,12 @@
         "node": ">= 0.10"
       }
     },
+    "node_modules/proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
+      "license": "MIT"
+    },
     "node_modules/pstree.remy": {
       "version": "1.1.8",
       "resolved": "https://registry.npmjs.org/pstree.remy/-/pstree.remy-1.1.8.tgz",
diff --git a/package.json b/package.json
index 86e563d..8236f7a 100644
--- a/package.json
+++ b/package.json
@@ -10,14 +10,16 @@
     "test:watch": "cross-env NODE_ENV=test jest --watch --detectOpenHandles --forceExit",
     "test:coverage": "cross-env NODE_ENV=test jest --coverage --detectOpenHandles --forceExit",
     "lint": "eslint .",
-    "format": "prettier --write ."
+    "format": "prettier --write .",
+    "init:zerodb": "node scripts/initZeroDB.js",
+    "test:zerodb": "node scripts/testZeroDB.js"
   },
-
   "dependencies": {
     "@langchain/anthropic": "^0.3.8",
     "@langchain/core": "^0.3.18",
     "@langchain/langgraph": "^0.2.22",
     "argon2": "^0.40.3",
+    "axios": "^1.10.0",
     "bcrypt": "^5.1.1",
     "compression": "^1.8.0",
     "cookie-parser": "^1.4.7",
@@ -46,6 +48,7 @@
     "uuid": "^11.1.0"
   },
   "devDependencies": {
+    "@playwright/test": "^1.53.2",
     "cross-env": "^7.0.3",
     "eslint": "^8.56.0",
     "eslint-config-prettier": "^9.1.0",
diff --git a/playwright.config.js b/playwright.config.js
new file mode 100644
index 0000000..35f8e83
--- /dev/null
+++ b/playwright.config.js
@@ -0,0 +1,59 @@
+/**
+ * Playwright Configuration for OpenCap E2E Tests
+ * 
+ * Comprehensive E2E testing setup for user journey testing
+ */
+
+const { defineConfig, devices } = require('@playwright/test');
+
+module.exports = defineConfig({
+  testDir: './e2e',
+  fullyParallel: true,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 2 : 0,
+  workers: process.env.CI ? 1 : undefined,
+  reporter: [
+    ['html'],
+    ['json', { outputFile: 'test-results/results.json' }],
+    ['junit', { outputFile: 'test-results/results.xml' }]
+  ],
+  use: {
+    baseURL: process.env.BASE_URL || 'http://localhost:3000',
+    trace: 'on-first-retry',
+    screenshot: 'only-on-failure',
+    video: 'retain-on-failure',
+    actionTimeout: 10000,
+    navigationTimeout: 30000
+  },
+
+  projects: [
+    {
+      name: 'chromium',
+      use: { ...devices['Desktop Chrome'] },
+    },
+    {
+      name: 'firefox',
+      use: { ...devices['Desktop Firefox'] },
+    },
+    {
+      name: 'webkit',
+      use: { ...devices['Desktop Safari'] },
+    },
+    // Mobile testing
+    {
+      name: 'Mobile Chrome',
+      use: { ...devices['Pixel 5'] },
+    },
+    {
+      name: 'Mobile Safari',
+      use: { ...devices['iPhone 12'] },
+    },
+  ],
+
+  webServer: {
+    command: 'npm run dev',
+    url: 'http://localhost:3000',
+    reuseExistingServer: !process.env.CI,
+    timeout: 120 * 1000,
+  },
+});
\ No newline at end of file
diff --git a/quick-start.js b/quick-start.js
new file mode 100644
index 0000000..fb05918
--- /dev/null
+++ b/quick-start.js
@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+console.log('🚀 OpenCap Quick Start Script');
+console.log('==============================\n');
+
+// Check if we're in the right directory
+const projectRoot = '/Volumes/Cody/projects/opencap-clean';
+const frontendDir = path.join(projectRoot, 'frontend');
+
+// Check if directories exist
+if (!fs.existsSync(projectRoot)) {
+  console.error('❌ Project root directory not found:', projectRoot);
+  process.exit(1);
+}
+
+if (!fs.existsSync(frontendDir)) {
+  console.error('❌ Frontend directory not found:', frontendDir);
+  process.exit(1);
+}
+
+console.log('✅ Project directories found');
+console.log('📂 Project root:', projectRoot);
+console.log('📂 Frontend dir:', frontendDir);
+
+// Function to start backend
+function startBackend() {
+  console.log('\n🔧 Starting Backend Server...');
+  
+  const backend = spawn('/opt/homebrew/bin/node', ['app.js'], {
+    cwd: projectRoot,
+    stdio: ['inherit', 'pipe', 'pipe'],
+    env: { ...process.env, NODE_ENV: 'development' }
+  });
+
+  backend.stdout.on('data', (data) => {
+    console.log('BACKEND:', data.toString().trim());
+  });
+
+  backend.stderr.on('data', (data) => {
+    console.error('BACKEND ERROR:', data.toString().trim());
+  });
+
+  backend.on('error', (error) => {
+    console.error('❌ Backend failed to start:', error.message);
+  });
+
+  return backend;
+}
+
+// Function to start frontend
+function startFrontend() {
+  console.log('\n🎨 Starting Frontend Server...');
+  
+  const frontend = spawn('/opt/homebrew/bin/npm', ['run', 'dev'], {
+    cwd: frontendDir,
+    stdio: ['inherit', 'pipe', 'pipe'],
+    env: { ...process.env, PATH: '/opt/homebrew/bin:' + process.env.PATH }
+  });
+
+  frontend.stdout.on('data', (data) => {
+    console.log('FRONTEND:', data.toString().trim());
+  });
+
+  frontend.stderr.on('data', (data) => {
+    console.error('FRONTEND ERROR:', data.toString().trim());
+  });
+
+  frontend.on('error', (error) => {
+    console.error('❌ Frontend failed to start:', error.message);
+  });
+
+  return frontend;
+}
+
+// Start both servers
+const backendProcess = startBackend();
+const frontendProcess = startFrontend();
+
+// Handle shutdown
+function shutdown() {
+  console.log('\n🛑 Shutting down servers...');
+  
+  if (backendProcess) {
+    backendProcess.kill('SIGTERM');
+  }
+  
+  if (frontendProcess) {
+    frontendProcess.kill('SIGTERM');
+  }
+  
+  setTimeout(() => {
+    process.exit(0);
+  }, 2000);
+}
+
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);
+
+// Wait a moment then show URLs
+setTimeout(() => {
+  console.log('\n🌐 Servers should be starting...');
+  console.log('📍 Backend API:  http://localhost:5000');
+  console.log('📍 Frontend App: http://localhost:5173');
+  console.log('📚 API Docs:     http://localhost:5000/api-docs');
+  console.log('\n💡 Press Ctrl+C to stop both servers');
+}, 3000);
+
+// Keep the script running
+setInterval(() => {
+  // Just keep alive
+}, 1000);
\ No newline at end of file
diff --git a/run-servers.sh b/run-servers.sh
new file mode 100644
index 0000000..9e6c39d
--- /dev/null
+++ b/run-servers.sh
@@ -0,0 +1,86 @@
+#!/bin/bash
+
+echo "🚀 Starting OpenCap Servers..."
+echo "Using Node.js from: /opt/homebrew/bin/node"
+
+# Set the PATH to include homebrew
+export PATH="/opt/homebrew/bin:$PATH"
+
+# Navigate to project root
+cd /Volumes/Cody/projects/opencap-clean
+
+# Check if Node.js is available
+if ! command -v node &> /dev/null; then
+    echo "❌ Node.js not found even with PATH set"
+    exit 1
+fi
+
+echo "✅ Node.js version: $(node --version)"
+echo "✅ npm version: $(npm --version)"
+
+# Install backend dependencies if needed
+if [ ! -d "node_modules" ]; then
+    echo "📦 Installing backend dependencies..."
+    npm install
+fi
+
+# Install frontend dependencies if needed
+cd frontend
+if [ ! -d "node_modules" ]; then
+    echo "📦 Installing frontend dependencies..."
+    npm install
+fi
+cd ..
+
+# Start backend in background
+echo "🔧 Starting backend server..."
+node app.js > backend.log 2>&1 &
+BACKEND_PID=$!
+echo "✅ Backend started with PID: $BACKEND_PID"
+
+# Wait a moment for backend to start
+sleep 3
+
+# Start frontend in background
+echo "🎨 Starting frontend server..."
+cd frontend
+npm run dev > ../frontend.log 2>&1 &
+FRONTEND_PID=$!
+echo "✅ Frontend started with PID: $FRONTEND_PID"
+cd ..
+
+echo ""
+echo "🎉 Both servers are now running!"
+echo ""
+echo "📍 Backend API:  http://localhost:5000"
+echo "📍 Frontend App: http://localhost:5173"
+echo "📚 API Docs:     http://localhost:5000/api-docs"
+echo ""
+echo "📝 Logs:"
+echo "   Backend:  tail -f backend.log"
+echo "   Frontend: tail -f frontend.log"
+echo ""
+echo "🛑 To stop servers:"
+echo "   kill $BACKEND_PID $FRONTEND_PID"
+echo ""
+
+# Save PIDs for later cleanup
+echo $BACKEND_PID > backend.pid
+echo $FRONTEND_PID > frontend.pid
+
+echo "🌐 Open http://localhost:5173 in your browser!"
+echo "⏳ Servers are starting up... give them 10-15 seconds"
+
+# Wait for user input to stop
+echo ""
+echo "Press Enter to stop the servers..."
+read -r
+
+# Clean shutdown
+echo "🛑 Stopping servers..."
+kill $BACKEND_PID 2>/dev/null
+kill $FRONTEND_PID 2>/dev/null
+
+rm -f backend.pid frontend.pid backend.log frontend.log
+
+echo "✅ Servers stopped!"
\ No newline at end of file
diff --git a/scripts/cleanupTestFiles.js b/scripts/cleanupTestFiles.js
index d068437..ba6446d 100644
--- a/scripts/cleanupTestFiles.js
+++ b/scripts/cleanupTestFiles.js
@@ -35,8 +35,6 @@ const filesToRemove = [
 const testScriptsToKeep = [
   'scripts/test-shortcut-integration.js',
   'scripts/test-mongodb-connection.js',
-  'scripts/insertTestFinancialData.js',
-  'scripts/enhancedTestFinancialData.js',
   'scripts/cleanupTestFiles.js' // This script itself
 ];
 
diff --git a/scripts/enhancedTestFinancialData.js b/scripts/enhancedTestFinancialData.js
deleted file mode 100644
index 795e04c..0000000
--- a/scripts/enhancedTestFinancialData.js
+++ /dev/null
@@ -1,264 +0,0 @@
-/**
- * Enhanced Test Financial Data Script
- * [Feature] OCAE-402: Create comprehensive test data for financial metrics
- * 
- * This script populates the database with comprehensive test data for testing
- * financial metrics and dashboard functionality.
- */
-
-const mongoose = require('mongoose');
-const dotenv = require('dotenv');
-const FinancialReport = require('../models/financialReport');
-const Company = require('../models/Company');
-const { connectToMongoDB } = require('../db/mongoConnection');
-
-// Load environment variables
-dotenv.config();
-
-// Test company and user IDs
-const TEST_COMPANY_ID = '682a927938afe0dda2cc609a';
-const TEST_USER_ID = '682a8d7b5ed376313af1529f';
-
-/**
- * Generate quarterly financial data for a given year and quarter
- */
-function generateQuarterlyData(year, quarter, baseRevenue, baseExpenses, variation = 0.1) {
-  const quarterMultipliers = {
-    Q1: 0.9, // Start of year is typically slower
-    Q2: 1.0,
-    Q3: 1.0,
-    Q4: 1.1  // End of year boost
-  };
-  
-  // Add some randomness
-  const randomFactor = 1 + (Math.random() * 2 - 1) * variation;
-  const quarterFactor = quarterMultipliers[quarter] || 1.0;
-  
-  // Calculate revenue components
-  const sales = Math.round(baseRevenue.sales * quarterFactor * randomFactor);
-  const services = Math.round(baseRevenue.services * quarterFactor * randomFactor);
-  const otherRevenue = Math.round(baseRevenue.other * quarterFactor * randomFactor);
-  const totalRevenue = sales + services + otherRevenue;
-  
-  // Calculate expenses (with some correlation to revenue but less variable)
-  const salaries = Math.round(baseExpenses.salaries * (0.95 + Math.random() * 0.1));
-  const marketing = Math.round(baseExpenses.marketing * (0.9 + Math.random() * 0.2));
-  const operations = Math.round(baseExpenses.operations * (0.95 + Math.random() * 0.1));
-  const otherExpenses = Math.round(baseExpenses.other * (0.9 + Math.random() * 0.2));
-  const totalExpenses = salaries + marketing + operations + otherExpenses;
-  
-  // Calculate profit metrics
-  const grossProfit = totalRevenue - salaries - operations; // Simplified COGS
-  const operatingProfit = grossProfit - marketing - otherExpenses;
-  const netIncome = operatingProfit * 0.8; // Simple tax rate of 20%
-  
-  return {
-    companyId: TEST_COMPANY_ID,
-    reportingPeriod: `${year}-${quarter}`,
-    reportDate: new Date(
-      year, 
-      quarter === 'Q1' ? 2 : (quarter === 'Q2' ? 5 : (quarter === 'Q3' ? 8 : 11)),
-      quarter === 'Q1' ? 31 : (quarter === 'Q2' ? 30 : (quarter === 'Q3' ? 30 : 31))
-    ),
-    reportType: 'quarterly',
-    revenue: {
-      sales,
-      services,
-      other: otherRevenue,
-      total: totalRevenue
-    },
-    expenses: {
-      salaries,
-      marketing,
-      operations,
-      other: otherExpenses,
-      total: totalExpenses
-    },
-    profit: {
-      gross: grossProfit,
-      operating: operatingProfit,
-      net: netIncome
-    },
-    assets: {
-      current: Math.round(totalRevenue * 0.7 * (0.9 + Math.random() * 0.2)),
-      fixed: Math.round(totalRevenue * 1.2 * (0.9 + Math.random() * 0.2)),
-      total: 0 // Will be calculated
-    },
-    liabilities: {
-      current: Math.round(totalRevenue * 0.3 * (0.8 + Math.random() * 0.4)),
-      longTerm: Math.round(totalRevenue * 0.6 * (0.8 + Math.random() * 0.4)),
-      total: 0 // Will be calculated
-    },
-    equity: {
-      common: 0, // Will be calculated
-      retained: 0, // Will be calculated
-      total: 0    // Will be calculated
-    },
-    metrics: {
-      currentRatio: 0,
-      quickRatio: 0,
-      debtToEquity: 0,
-      returnOnAssets: 0,
-      returnOnEquity: 0
-    },
-    notes: `Test data for ${quarter} ${year}`,
-    userId: TEST_USER_ID,
-    isTestData: true
-  };
-}
-
-/**
- * Generate annual financial data by aggregating quarterly data
- */
-function generateAnnualData(year, quarterlyData) {
-  const annualData = {
-    companyId: TEST_COMPANY_ID,
-    reportingPeriod: `${year}-annual`,
-    reportDate: new Date(year, 11, 31),
-    reportType: 'annual',
-    revenue: { sales: 0, services: 0, other: 0, total: 0 },
-    expenses: { salaries: 0, marketing: 0, operations: 0, other: 0, total: 0 },
-    profit: { gross: 0, operating: 0, net: 0 },
-    assets: { current: 0, fixed: 0, total: 0 },
-    liabilities: { current: 0, longTerm: 0, total: 0 },
-    equity: { common: 0, retained: 0, total: 0 },
-    metrics: {},
-    notes: `Annual report for ${year}`,
-    userId: TEST_USER_ID,
-    isTestData: true
-  };
-
-  // Sum up quarterly data
-  quarterlyData.forEach(q => {
-    annualData.revenue.sales += q.revenue.sales;
-    annualData.revenue.services += q.revenue.services;
-    annualData.revenue.other += q.revenue.other;
-    annualData.revenue.total += q.revenue.total;
-    
-    annualData.expenses.salaries += q.expenses.salaries;
-    annualData.expenses.marketing += q.expenses.marketing;
-    annualData.expenses.operations += q.expenses.operations;
-    annualData.expenses.other += q.expenses.other;
-    annualData.expenses.total += q.expenses.total;
-    
-    annualData.profit.gross += q.profit.gross;
-    annualData.profit.operating += q.profit.operating;
-    annualData.profit.net += q.profit.net;
-    
-    // Use Q4 values for annual balance sheet items
-    if (q.reportingPeriod.endsWith('Q4')) {
-      annualData.assets = { ...q.assets };
-      annualData.liabilities = { ...q.liabilities };
-      annualData.equity = { ...q.equity };
-    }
-  });
-
-  return annualData;
-}
-
-async function insertTestData() {
-  try {
-    // Connect to MongoDB
-    await connectToMongoDB();
-    console.log('✅ Connected to MongoDB');
-    
-    // Ensure the test company exists
-    let company = await Company.findById(TEST_COMPANY_ID);
-    if (!company) {
-      console.log('Creating test company...');
-      company = new Company({
-        _id: TEST_COMPANY_ID,
-        companyId: 'TESTCOMPANY001',
-        CompanyName: 'Test Company Inc.',
-        CompanyType: 'corporation',
-        RegisteredAddress: '123 Test St, San Francisco, CA 94105, USA',
-        TaxID: '12-3456789',
-        corporationDate: new Date('2020-01-01'),
-        industry: 'Technology',
-        isActive: true,
-        financialYearEnd: 12, // December
-        currency: 'USD',
-        timezone: 'America/Los_Angeles',
-        settings: {
-          fiscalYearStartMonth: 1, // January
-          reportingCurrency: 'USD',
-          taxRate: 0.2 // 20%
-        },
-        createdBy: TEST_USER_ID,
-        updatedBy: TEST_USER_ID
-      });
-      await company.save();
-      console.log('✅ Created test company');
-    } else {
-      console.log('ℹ️ Using existing test company');
-    }
-
-    // Base financials for generating test data
-    const baseRevenue = {
-      sales: 150000,
-      services: 50000,
-      other: 10000
-    };
-    
-    const baseExpenses = {
-      salaries: 80000,
-      marketing: 20000,
-      operations: 30000,
-      other: 10000
-    };
-
-    // Generate test data for multiple years
-    const years = [2022, 2023, 2024];
-    const quarters = ['Q1', 'Q2', 'Q3', 'Q4'];
-    
-    // Delete any existing test data for this company
-    await FinancialReport.deleteMany({ 
-      $or: [
-        { companyId: TEST_COMPANY_ID },
-        { isTestData: true }
-      ]
-    });
-    console.log('🧹 Cleared existing test data for company', TEST_COMPANY_ID);
-    
-    // Generate and insert test data
-    for (const year of years) {
-      const yearlyData = [];
-      
-      // Generate quarterly data
-      for (const quarter of quarters) {
-        // Skip future quarters in the current year
-        if (year === new Date().getFullYear()) {
-          const currentQuarter = Math.floor((new Date().getMonth() + 3) / 3);
-          const quarterNum = parseInt(quarter[1]);
-          if (quarterNum > currentQuarter) continue;
-        }
-        
-        const quarterlyData = generateQuarterlyData(year, quarter, baseRevenue, baseExpenses);
-        yearlyData.push(quarterlyData);
-      }
-      
-      // Generate and add annual data
-      if (yearlyData.length > 0) {
-        const annualData = generateAnnualData(year, yearlyData);
-        yearlyData.push(annualData);
-      }
-      
-      // Insert all data for the year
-      if (yearlyData.length > 0) {
-        await FinancialReport.insertMany(yearlyData);
-        console.log(`✅ Inserted ${yearlyData.length} financial records for ${year}`);
-      }
-    }
-    
-    console.log('\n🎉 Test data generation complete!');
-    console.log(`Total financial records: ${await FinancialReport.countDocuments({ isTestData: true })}`);
-    
-    process.exit(0);
-  } catch (error) {
-    console.error('❌ Error generating test data:', error);
-    process.exit(1);
-  }
-}
-
-// Run the script
-insertTestData();
diff --git a/scripts/initZeroDB.js b/scripts/initZeroDB.js
new file mode 100644
index 0000000..c3bdb9e
--- /dev/null
+++ b/scripts/initZeroDB.js
@@ -0,0 +1,380 @@
+#!/usr/bin/env node
+
+/**
+ * ZeroDB Initialization Script for OpenCap
+ * 
+ * This script initializes the ZeroDB project and sets up the lakehouse infrastructure
+ * for OpenCap including vector search, real-time streaming, and memory management
+ */
+
+const jwt = require('jsonwebtoken');
+const zerodbService = require('../services/zerodbService');
+const vectorService = require('../services/vectorService');
+const streamingService = require('../services/streamingService');
+const memoryService = require('../services/memoryService');
+
+// Configuration
+const config = {
+  secretKey: process.env.JWT_SECRET || 'your-secret-key-here',
+  userId: process.env.OPENCAP_USER_ID || 'opencap-system-user',
+  userEmail: process.env.OPENCAP_USER_EMAIL || 'system@opencap.ai'
+};
+
+/**
+ * Generate JWT token for system operations
+ */
+function generateSystemToken() {
+  const payload = {
+    sub: config.userId,
+    role: 'ADMIN',
+    email: config.userEmail,
+    iat: Math.floor(Date.now() / 1000),
+    exp: Math.floor(Date.now() / 1000) + (24 * 60 * 60) // 24 hours
+  };
+  
+  return jwt.sign(payload, config.secretKey, { algorithm: 'HS256' });
+}
+
+/**
+ * Initialize ZeroDB project
+ */
+async function initializeProject() {
+  console.log('🚀 Initializing ZeroDB for OpenCap...');
+  
+  try {
+    const token = generateSystemToken();
+    console.log('✅ Generated system JWT token');
+    
+    // Initialize services
+    console.log('🔧 Initializing ZeroDB services...');
+    await zerodbService.initialize(token);
+    await vectorService.initialize(token);
+    await streamingService.initialize(token);
+    await memoryService.initialize(token);
+    
+    console.log('✅ All services initialized successfully');
+    
+    // Get project status
+    const dbStatus = await zerodbService.getDatabaseStatus();
+    console.log('📊 Database Status:', dbStatus);
+    
+    return {
+      success: true,
+      projectId: zerodbService.projectId,
+      databaseStatus: dbStatus
+    };
+  } catch (error) {
+    console.error('❌ Failed to initialize ZeroDB:', error);
+    throw error;
+  }
+}
+
+/**
+ * Set up initial tables and schemas
+ */
+async function setupTables() {
+  console.log('📋 Setting up initial tables...');
+  
+  try {
+    // Financial Reports table
+    await zerodbService.createTable('financial_reports', {
+      id: 'uuid',
+      company_id: 'string',
+      report_type: 'string',
+      reporting_period: 'string',
+      total_revenue: 'decimal',
+      total_expenses: 'decimal',
+      net_income: 'decimal',
+      created_at: 'timestamp',
+      updated_at: 'timestamp'
+    });
+    console.log('✅ Created financial_reports table');
+    
+    // Documents table
+    await zerodbService.createTable('documents', {
+      id: 'uuid',
+      document_name: 'string',
+      document_type: 'string',
+      file_size: 'integer',
+      content_type: 'string',
+      company_id: 'string',
+      access_level: 'string',
+      created_at: 'timestamp'
+    });
+    console.log('✅ Created documents table');
+    
+    // SPV table
+    await zerodbService.createTable('spvs', {
+      id: 'uuid',
+      spv_name: 'string',
+      spv_type: 'string',
+      total_commitment: 'decimal',
+      investor_count: 'integer',
+      status: 'string',
+      created_at: 'timestamp'
+    });
+    console.log('✅ Created spvs table');
+    
+    // Users activity table
+    await zerodbService.createTable('user_activities', {
+      id: 'uuid',
+      user_id: 'string',
+      activity_type: 'string',
+      entity_type: 'string',
+      entity_id: 'string',
+      timestamp: 'timestamp',
+      metadata: 'json'
+    });
+    console.log('✅ Created user_activities table');
+    
+    console.log('✅ All tables created successfully');
+  } catch (error) {
+    console.error('❌ Error setting up tables:', error);
+    // Don't throw - tables might already exist
+    console.log('⚠️  Some tables may already exist, continuing...');
+  }
+}
+
+/**
+ * Test vector operations
+ */
+async function testVectorOperations() {
+  console.log('🧪 Testing vector operations...');
+  
+  try {
+    // Test document indexing
+    const testDocId = 'test-financial-report-001';
+    const testContent = 'Financial Report Q1 2024: Revenue $1,000,000, Expenses $600,000, Net Income $400,000. Strong performance in technology sector.';
+    
+    await vectorService.indexDocument(
+      testDocId,
+      'Q1 2024 Financial Report',
+      testContent,
+      'financial_report',
+      {
+        company_id: 'test-company-001',
+        report_type: 'quarterly',
+        reporting_period: 'Q1 2024',
+        total_revenue: 1000000,
+        total_expenses: 600000,
+        net_income: 400000
+      }
+    );
+    console.log('✅ Test document indexed successfully');
+    
+    // Test vector search
+    const searchResults = await vectorService.searchFinancialDocuments(
+      'quarterly financial performance revenue',
+      5
+    );
+    console.log('✅ Vector search test completed:', {
+      query: 'quarterly financial performance revenue',
+      results_count: searchResults.results.length,
+      search_time_ms: searchResults.search_time_ms
+    });
+    
+    console.log('✅ Vector operations test completed');
+  } catch (error) {
+    console.error('❌ Vector operations test failed:', error);
+    throw error;
+  }
+}
+
+/**
+ * Test streaming operations
+ */
+async function testStreamingOperations() {
+  console.log('🌊 Testing streaming operations...');
+  
+  try {
+    // Test financial transaction event
+    await streamingService.publishFinancialTransaction({
+      id: 'test-transaction-001',
+      type: 'financial_report_created',
+      amount: 1000000,
+      currency: 'USD',
+      companyId: 'test-company-001',
+      category: 'quarterly_report',
+      status: 'created'
+    }, config.userId);
+    console.log('✅ Financial transaction event published');
+    
+    // Test user activity event
+    await streamingService.publishUserActivity(
+      config.userId,
+      'system_initialization',
+      {
+        sessionId: 'init-session-001',
+        feature: 'zerodb_setup',
+        success: true
+      }
+    );
+    console.log('✅ User activity event published');
+    
+    // Test system alert
+    await streamingService.publishSystemAlert(
+      'system_initialization',
+      'low',
+      'ZeroDB initialization completed successfully',
+      {
+        component: 'zerodb_service',
+        affected_users: [config.userId]
+      }
+    );
+    console.log('✅ System alert published');
+    
+    console.log('✅ Streaming operations test completed');
+  } catch (error) {
+    console.error('❌ Streaming operations test failed:', error);
+    throw error;
+  }
+}
+
+/**
+ * Test memory operations
+ */
+async function testMemoryOperations() {
+  console.log('🧠 Testing memory operations...');
+  
+  try {
+    // Create test session
+    const sessionId = await memoryService.createSession(config.userId, {
+      userAgent: 'OpenCap-Init-Script/1.0',
+      ipAddress: '127.0.0.1',
+      deviceType: 'server',
+      browser: 'node'
+    });
+    console.log('✅ Test session created:', sessionId);
+    
+    // Store test workflow state
+    await memoryService.storeWorkflowState(
+      'zerodb-initialization',
+      sessionId,
+      'completed',
+      {
+        step: 'final',
+        progress: 100,
+        duration_ms: Date.now()
+      },
+      {
+        userId: config.userId,
+        automated: true
+      }
+    );
+    console.log('✅ Workflow state stored');
+    
+    // Test caching
+    await memoryService.cacheData(
+      'system_status',
+      {
+        status: 'healthy',
+        initialized_at: new Date().toISOString(),
+        version: '1.0.0'
+      },
+      5 * 60 * 1000 // 5 minutes
+    );
+    console.log('✅ System status cached');
+    
+    console.log('✅ Memory operations test completed');
+  } catch (error) {
+    console.error('❌ Memory operations test failed:', error);
+    throw error;
+  }
+}
+
+/**
+ * Get system analytics
+ */
+async function getSystemAnalytics() {
+  console.log('📈 Getting system analytics...');
+  
+  try {
+    // Get database status
+    const dbStatus = await zerodbService.getDatabaseStatus();
+    
+    // Get tables
+    const tables = await zerodbService.listTables();
+    
+    // Get streaming analytics
+    const streamingAnalytics = await streamingService.getAnalytics('financial_transaction', '1h');
+    
+    const analytics = {
+      database: dbStatus,
+      tables: tables.map(t => ({
+        name: t.table_name,
+        created_at: t.created_at
+      })),
+      streaming: {
+        total_events: streamingAnalytics.total_events,
+        events_per_hour: Object.keys(streamingAnalytics.events_per_hour).length
+      },
+      initialization_completed_at: new Date().toISOString()
+    };
+    
+    console.log('📊 System Analytics:', JSON.stringify(analytics, null, 2));
+    return analytics;
+  } catch (error) {
+    console.error('❌ Failed to get system analytics:', error);
+    throw error;
+  }
+}
+
+/**
+ * Main initialization function
+ */
+async function main() {
+  console.log('🎯 Starting OpenCap ZeroDB Initialization...\n');
+  
+  try {
+    // Step 1: Initialize project
+    const initResult = await initializeProject();
+    console.log(`📋 Project ID: ${initResult.projectId}\n`);
+    
+    // Step 2: Set up tables
+    await setupTables();
+    console.log('');
+    
+    // Step 3: Test vector operations
+    await testVectorOperations();
+    console.log('');
+    
+    // Step 4: Test streaming operations
+    await testStreamingOperations();
+    console.log('');
+    
+    // Step 5: Test memory operations
+    await testMemoryOperations();
+    console.log('');
+    
+    // Step 6: Get analytics
+    const analytics = await getSystemAnalytics();
+    console.log('');
+    
+    console.log('🎉 OpenCap ZeroDB initialization completed successfully!');
+    console.log('');
+    console.log('Next steps:');
+    console.log('1. Update your application to use the ZeroDB services');
+    console.log('2. Configure authentication tokens for production');
+    console.log('3. Set up monitoring and alerting');
+    console.log('4. Review the generated analytics above');
+    
+    process.exit(0);
+  } catch (error) {
+    console.error('💥 Initialization failed:', error);
+    process.exit(1);
+  }
+}
+
+// Handle CLI execution
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  initializeProject,
+  setupTables,
+  testVectorOperations,
+  testStreamingOperations,
+  testMemoryOperations,
+  getSystemAnalytics
+};
\ No newline at end of file
diff --git a/scripts/insertTestFinancialData.js b/scripts/insertTestFinancialData.js
deleted file mode 100644
index 398ca00..0000000
--- a/scripts/insertTestFinancialData.js
+++ /dev/null
@@ -1,140 +0,0 @@
-/**
- * Script to insert test financial data for API testing
- * [Feature] OCAE-402: Create financial metrics calculation endpoints
- */
-
-const mongoose = require('mongoose');
-const dotenv = require('dotenv');
-const FinancialReport = require('../models/financialReport');
-const { connectToMongoDB } = require('../db/mongoConnection');
-
-// Load environment variables
-dotenv.config();
-
-// Use MongoDB container connection
-process.env.MONGODB_URI = 'mongodb://opencapapp:password123@mongodb:27017/opencap?authSource=opencap';
-
-// Enable debug mode
-process.env.DEBUG = 'mongoose:*';
-
-// Set mongoose debug
-mongoose.set('debug', true);
-
-// Test company ID (created earlier)
-const TEST_COMPANY_ID = '682a927938afe0dda2cc609a';
-const TEST_USER_ID = '682a8d7b5ed376313af1529f'; // From the test user we've been using
-
-// Test financial data for Q2 2024
-const testFinancialData = [
-  // Q2 2024 (current quarter)
-  {
-    companyId: TEST_COMPANY_ID,
-    reportingPeriod: '2024-Q2',
-    reportDate: new Date('2024-06-30'),
-    reportType: 'quarterly',
-    revenue: {
-      sales: 150000,
-      services: 50000,
-      other: 10000
-    },
-    expenses: {
-      salaries: 80000,
-      marketing: 20000,
-      operations: 30000,
-      other: 10000
-    },
-    notes: 'Q2 2024 financial report',
-    userId: TEST_USER_ID
-  },
-  // Q1 2024 (previous quarter for comparison)
-  {
-    companyId: TEST_COMPANY_ID,
-    reportingPeriod: '2024-Q1',
-    reportDate: new Date('2024-03-31'),
-    reportType: 'quarterly',
-    revenue: {
-      sales: 120000,
-      services: 45000,
-      other: 8000
-    },
-    expenses: {
-      salaries: 75000,
-      marketing: 18000,
-      operations: 28000,
-      other: 9000
-    },
-    notes: 'Q1 2024 financial report',
-    userId: TEST_USER_ID
-  },
-  // Full year 2023 (for annual comparison)
-  {
-    companyId: TEST_COMPANY_ID,
-    reportingPeriod: '2023-annual',
-    reportDate: new Date('2023-12-31'),
-    reportType: 'annual',
-    revenue: {
-      sales: 400000,
-      services: 160000,
-      other: 30000
-    },
-    expenses: {
-      salaries: 280000,
-      marketing: 60000,
-      operations: 100000,
-      other: 30000
-    },
-    notes: 'Full year 2023 financial report',
-    userId: TEST_USER_ID
-  }
-];
-
-async function insertTestData() {
-  try {
-    // Connect to MongoDB
-    await connectToMongoDB();
-    console.log('Connected to MongoDB');
-    
-    // Get the model to ensure it's registered with the correct collection name
-    const collectionName = FinancialReport.collection.name;
-    console.log(`Using collection: ${collectionName}`);
-    
-    // Delete any existing test data
-    const deleteResult = await FinancialReport.deleteMany({ companyId: TEST_COMPANY_ID });
-    console.log(`Cleaned up ${deleteResult.deletedCount} existing test records`);
-    
-    console.log('Inserting test data...');
-    // Insert test data one by one for better error reporting
-    const reports = [];
-    for (const data of testFinancialData) {
-      try {
-        const report = new FinancialReport(data);
-        await report.save();
-        reports.push(report);
-        console.log(`Inserted report for ${data.reportingPeriod}`);
-      } catch (insertError) {
-        console.error(`Error inserting report for ${data.reportingPeriod}:`, insertError.message);
-        throw insertError; // Re-throw to be caught by the outer try-catch
-      }
-    }
-    console.log(`Successfully inserted ${reports.length} financial reports`);
-    
-    // Calculate and display some basic metrics
-    const companyReports = await FinancialReport.find({ companyId: TEST_COMPANY_ID }).lean();
-    console.log('\nTest data summary:');
-    companyReports.forEach(report => {
-      console.log(`\n${report.reportingPeriod}:`);
-      console.log(`- Total Revenue: $${(report.totalRevenue || 0).toLocaleString()}`);
-      console.log(`- Total Expenses: $${(report.totalExpenses || 0).toLocaleString()}`);
-      console.log(`- Net Income: $${(report.netIncome || 0).toLocaleString()}`);
-    });
-    
-    console.log('\nTest data insertion completed successfully!');
-    process.exit(0);
-  } catch (error) {
-    console.error('Error inserting test data:', error);
-    process.exit(1);
-  }
-}
-
-// Run the script
-insertTestData();
diff --git a/scripts/seedDatabase.js b/scripts/seedDatabase.js
index d02a598..eddd434 100644
--- a/scripts/seedDatabase.js
+++ b/scripts/seedDatabase.js
@@ -1,277 +1,402 @@
 /**
- * Database Seed Script
+ * Database Seeding Script
  * 
- * [Feature] OCDI-106: Database seed script
- * 
- * This script provides functionality to seed the database with initial data
- * for development and testing purposes. It includes:
- * - Admin user creation
- * - Sample companies
- * - Sample share classes
- * - Sample financial reports
- * 
- * Usage:
- * - Development: `node scripts/seedDatabase.js`
- * - Programmatic: `const { seedDatabase } = require('./scripts/seedDatabase'); await seedDatabase();`
+ * Seeds the database with realistic data for development and testing
+ * NO MOCK DATA - All data is designed to be pulled via real APIs
  */
 
 const mongoose = require('mongoose');
+const bcrypt = require('bcrypt');
+const dotenv = require('dotenv');
+const { connectToMongoDB } = require('../db/mongoConnection');
+
+// Load environment variables
+dotenv.config();
+
+// Import models
 const User = require('../models/User');
 const Company = require('../models/Company');
-const ShareClass = require('../models/ShareClass');
 const FinancialReport = require('../models/financialReport');
-require('dotenv').config();
+const Activity = require('../models/Activity');
+const Notification = require('../models/Notification');
+const Document = require('../models/Document');
+
+// Seed data configuration
+const SEED_CONFIG = {
+  companies: 3,
+  usersPerCompany: 5,
+  financialReportsPerCompany: 12,
+  activitiesPerCompany: 20,
+  notificationsPerUser: 5,
+  documentsPerCompany: 10
+};
+
+async function seedDatabase() {
+  try {
+    console.log('🌱 Starting database seeding...');
+    
+    // Connect to MongoDB
+    await connectToMongoDB();
+    
+    // Clear existing data
+    await clearDatabase();
+    
+    // Seed companies
+    const companies = await seedCompanies();
+    
+    // Seed users for each company
+    const users = await seedUsers(companies);
+    
+    // Seed financial reports
+    await seedFinancialReports(companies, users);
+    
+    // Seed activities
+    await seedActivities(companies, users);
+    
+    // Seed notifications
+    await seedNotifications(users);
+    
+    // Seed documents
+    await seedDocuments(companies, users);
+    
+    console.log('✅ Database seeding completed successfully!');
+    
+  } catch (error) {
+    console.error('❌ Database seeding failed:', error);
+  } finally {
+    await mongoose.connection.close();
+  }
+}
+
+async function clearDatabase() {
+  console.log('🧹 Clearing existing data...');
+  
+  const collections = [
+    'users', 'companies', 'financialreports', 'activities', 
+    'notifications', 'documents'
+  ];
+  
+  for (const collection of collections) {
+    try {
+      await mongoose.connection.db.collection(collection).deleteMany({});
+      console.log(`  ✓ Cleared ${collection}`);
+    } catch (error) {
+      console.warn(`  ⚠️  Could not clear ${collection}:`, error.message);
+    }
+  }
+}
 
-// Sample data for seeding
-const SAMPLE_DATA = {
-  admin: {
-    email: 'admin@opencap.com',
-    password: process.env.SEED_ADMIN_PASSWORD || 'AdminPassword123!',
-    firstName: 'Admin',
-    lastName: 'User',
-    role: 'admin'
-  },
-  companies: [
+async function seedCompanies() {
+  console.log('🏢 Seeding companies...');
+  
+  const companyData = [
     {
-      companyId: 'COMP001',
-      CompanyName: 'TechVentures Inc.',
+      companyId: 'COMP_001',
+      CompanyName: 'CloudTech Solutions',
       CompanyType: 'startup',
-      RegisteredAddress: '123 Innovation Drive, San Francisco, CA 94107',
+      RegisteredAddress: '123 Tech Boulevard, San Francisco, CA 94105',
       TaxID: '12-3456789',
-      corporationDate: new Date('2022-01-15')
+      corporationDate: new Date('2020-01-15')
     },
     {
-      companyId: 'COMP002',
-      CompanyName: 'BlueOcean Solutions',
+      companyId: 'COMP_002',
+      CompanyName: 'EcoGen Power',
       CompanyType: 'corporation',
-      RegisteredAddress: '456 Enterprise Avenue, Boston, MA 02108',
+      RegisteredAddress: '456 Green Valley Road, Austin, TX 78701',
       TaxID: '98-7654321',
-      corporationDate: new Date('2021-05-10')
+      corporationDate: new Date('2019-03-10')
     },
     {
-      companyId: 'COMP003',
-      CompanyName: 'GreenField Innovations',
+      companyId: 'COMP_003',
+      CompanyName: 'MediSync Health',
       CompanyType: 'startup',
-      RegisteredAddress: '789 Startup Lane, Austin, TX 78701',
-      TaxID: '45-6789123',
-      corporationDate: new Date('2023-03-22')
-    }
-  ],
-  shareClasses: [
-    {
-      name: 'Common Stock',
-      description: 'Standard common stock with voting rights',
-      companyId: 'COMP001',
-      shareClassId: 'SC001-COMP001',
-      votingRights: true,
-      liquidationPreference: 1.0,
-      conversionRights: false,
-      antiDilutionProtection: false
-    },
-    {
-      name: 'Series A Preferred',
-      description: 'Preferred shares with liquidation preference',
-      companyId: 'COMP001',
-      shareClassId: 'SC002-COMP001',
-      votingRights: true,
-      liquidationPreference: 1.5,
-      conversionRights: true,
-      antiDilutionProtection: true
-    },
-    {
-      name: 'Common Stock',
-      description: 'Standard common stock with voting rights',
-      companyId: 'COMP002',
-      shareClassId: 'SC001-COMP002',
-      votingRights: true,
-      liquidationPreference: 1.0,
-      conversionRights: false,
-      antiDilutionProtection: false
-    }
-  ],
-  financialReports: [
-    {
-      companyId: 'COMP001',
-      reportingPeriod: '2023-Q1',
-      reportDate: new Date('2023-03-31'),
-      reportType: 'quarterly',
-      revenue: {
-        sales: 250000,
-        services: 100000,
-        other: 25000
-      },
-      expenses: {
-        salaries: 150000,
-        marketing: 50000,
-        operations: 75000,
-        other: 25000
-      },
-      notes: 'Q1 performance exceeded expectations with new product launch',
-      userId: 'ADMIN-USER-ID' // Default placeholder, will be replaced if possible
-    },
-    {
-      companyId: 'COMP001',
-      reportingPeriod: '2023-Q2',
-      reportDate: new Date('2023-06-30'),
-      reportType: 'quarterly',
-      revenue: {
-        sales: 300000,
-        services: 120000,
-        other: 30000
-      },
-      expenses: {
-        salaries: 160000,
-        marketing: 60000,
-        operations: 80000,
-        other: 30000
-      },
-      notes: 'Q2 showed continued growth in core product lines',
-      userId: 'ADMIN-USER-ID' // Default placeholder, will be replaced if possible
+      RegisteredAddress: '789 Health Plaza, Boston, MA 02101',
+      TaxID: '55-9876543',
+      corporationDate: new Date('2021-06-20')
     }
-  ]
-};
+  ];
+  
+  const companies = [];
+  for (const data of companyData) {
+    const company = new Company(data);
+    await company.save();
+    companies.push(company);
+    console.log(`  ✓ Created company: ${company.CompanyName}`);
+  }
+  
+  return companies;
+}
 
-/**
- * Seed database with initial data
- * @returns {Promise<void>}
- */
-async function seedDatabase() {
-  try {
-    console.log('🌱 Starting database seeding...');
+async function seedUsers(companies) {
+  console.log('👥 Seeding users...');
+  
+  const userRoles = ['admin', 'founder', 'employee', 'investor', 'advisor'];
+  const users = [];
+  
+  for (const company of companies) {
+    const companyUsers = [];
     
-    // Create admin user if it doesn't exist
-    const adminExists = await User.exists({ email: SAMPLE_DATA.admin.email });
-    if (!adminExists) {
-      console.log('Creating admin user...');
-      const admin = await User.create(SAMPLE_DATA.admin);
-      console.log(`✅ Admin user created with ID: ${admin && admin._id ? admin._id : 'ADMIN-USER-ID'}`);
+    for (let i = 0; i < SEED_CONFIG.usersPerCompany; i++) {
+      const hashedPassword = await bcrypt.hash('SecurePassword123!', 10);
       
-      // Set admin user ID for financial reports if available
-      if (admin && admin._id) {
-        SAMPLE_DATA.financialReports.forEach(report => {
-          report.userId = admin._id;
-        });
-      }
-    } else {
-      console.log('Admin user already exists, skipping...');
+      const firstName = getRandomFirstName();
+      const lastName = getRandomLastName();
       
-      try {
-        // Get admin user ID for financial reports
-        const admin = await User.findOne({ email: SAMPLE_DATA.admin.email });
-        if (admin && admin._id) {
-          SAMPLE_DATA.financialReports.forEach(report => {
-            report.userId = admin._id;
-          });
-        }
-      } catch (err) {
-        console.log('Unable to retrieve admin ID, using default placeholder');
-      }
-    }
-    
-    // Seed companies
-    for (const company of SAMPLE_DATA.companies) {
-      const companyExists = await Company.exists({ companyId: company.companyId });
-      if (!companyExists) {
-        await Company.create(company);
-        console.log(`✅ Created company: ${company.CompanyName}`);
-      } else {
-        console.log(`Company ${company.CompanyName} already exists, skipping...`);
-      }
+      const userData = {
+        userId: `USER_${Date.now()}_${i}`,
+        firstName: firstName,
+        lastName: lastName,
+        email: `user${i + 1}@${company.CompanyName.toLowerCase().replace(/\\s+/g, '')}.com`,
+        password: hashedPassword,
+        role: userRoles[i % userRoles.length] === 'founder' ? 'admin' : (userRoles[i % userRoles.length] === 'investor' ? 'client' : 'user'),
+        profile: {
+          bio: `${getRandomJobTitle()} at ${company.CompanyName}`,
+          phoneNumber: generatePhoneNumber(),
+          address: {
+            city: getRandomCity(),
+            state: getRandomState(),
+            country: 'US'
+          }
+        },
+        companyId: company._id,
+        isActive: true,
+        emailVerified: true
+      };
+      
+      const user = new User(userData);
+      await user.save();
+      companyUsers.push(user);
+      users.push(user);
+      
+      console.log(`  ✓ Created user: ${user.email} (${user.role})`);
     }
+  }
+  
+  return users;
+}
+
+async function seedFinancialReports(companies, users) {
+  console.log('📊 Seeding financial reports...');
+  
+  const reportTypes = ['quarterly', 'annual', 'monthly'];
+  const quarters = ['Q1', 'Q2', 'Q3', 'Q4'];
+  const years = [2022, 2023, 2024];
+  
+  for (const company of companies) {
+    const companyUsers = users.filter(u => u.companyId.toString() === company._id.toString());
+    const usedPeriods = new Set();
     
-    // Seed share classes
-    for (const shareClass of SAMPLE_DATA.shareClasses) {
-      const shareClassExists = await ShareClass.exists({ shareClassId: shareClass.shareClassId });
-      if (!shareClassExists) {
-        await ShareClass.create(shareClass);
-        console.log(`✅ Created share class: ${shareClass.name} for company ${shareClass.companyId}`);
-      } else {
-        console.log(`Share class ${shareClass.shareClassId} already exists, skipping...`);
-      }
+    for (let i = 0; i < SEED_CONFIG.financialReportsPerCompany; i++) {
+      let year, quarter, reportingPeriod;
+      
+      // Ensure unique reporting periods
+      do {
+        year = years[Math.floor(Math.random() * years.length)];
+        quarter = quarters[Math.floor(Math.random() * quarters.length)];
+        reportingPeriod = `${year}-${quarter}`;
+      } while (usedPeriods.has(reportingPeriod));
+      
+      usedPeriods.add(reportingPeriod);
+      
+      const baseRevenue = 50000 + (Math.random() * 450000);
+      const baseExpenses = baseRevenue * (0.6 + Math.random() * 0.3);
+      
+      const salesRevenue = Math.round(baseRevenue * 0.7);
+      const servicesRevenue = Math.round(baseRevenue * 0.25);
+      const otherRevenue = Math.round(baseRevenue * 0.05);
+      
+      const salariesExpenses = Math.round(baseExpenses * 0.6);
+      const marketingExpenses = Math.round(baseExpenses * 0.2);
+      const operationsExpenses = Math.round(baseExpenses * 0.15);
+      const otherExpenses = Math.round(baseExpenses * 0.05);
+      
+      const reportData = {
+        companyId: company._id,
+        reportingPeriod: reportingPeriod,
+        reportType: reportTypes[Math.floor(Math.random() * reportTypes.length)],
+        reportDate: new Date(year, Math.floor(Math.random() * 12), Math.floor(Math.random() * 28) + 1),
+        revenue: {
+          sales: salesRevenue,
+          services: servicesRevenue,
+          other: otherRevenue
+        },
+        expenses: {
+          salaries: salariesExpenses,
+          marketing: marketingExpenses,
+          operations: operationsExpenses,
+          other: otherExpenses
+        },
+        notes: `Financial report for ${company.CompanyName} - ${quarter} ${year}`,
+        userId: companyUsers[Math.floor(Math.random() * companyUsers.length)]._id
+      };
+      
+      const report = new FinancialReport(reportData);
+      await report.save();
+      
+      console.log(`  ✓ Created financial report: ${company.CompanyName} ${reportingPeriod}`);
     }
+  }
+}
+
+async function seedActivities(companies, users) {
+  console.log('📝 Seeding activities...');
+  
+  const activityTypes = ['DocumentUpload', 'StakeholderUpdate', 'FinancialReportCreated', 'UserLogin', 'SystemUpdate'];
+  
+  for (const company of companies) {
+    const companyUsers = users.filter(u => u.companyId.toString() === company._id.toString());
     
-    // Seed financial reports
-    for (const report of SAMPLE_DATA.financialReports) {
-      const reportExists = await FinancialReport.exists({ 
-        companyId: report.companyId,
-        reportingPeriod: report.reportingPeriod
-      });
+    for (let i = 0; i < SEED_CONFIG.activitiesPerCompany; i++) {
+      const activityType = activityTypes[Math.floor(Math.random() * activityTypes.length)];
+      const user = companyUsers[Math.floor(Math.random() * companyUsers.length)];
       
-      if (!reportExists) {
-        try {
-          // Support both direct create and constructor pattern for tests
-          if (typeof FinancialReport.create === 'function') {
-            await FinancialReport.create(report);
-          } else {
-            // Calculate totals before saving
-            const financialReport = new FinancialReport(report);
-            // Only call calculateTotals if it exists (in case of mocking)
-            if (typeof financialReport.calculateTotals === 'function') {
-              financialReport.calculateTotals();
-            }
-            await financialReport.save();
-          }
-          console.log(`✅ Created financial report: ${report.reportingPeriod} for company ${report.companyId}`);
-        } catch (err) {
-          console.log(`Error creating financial report: ${err.message}`);
-        }
-      } else {
-        console.log(`Financial report ${report.reportingPeriod} for company ${report.companyId} already exists, skipping...`);
-      }
+      const activityData = {
+        activityId: `ACT_${Date.now()}_${i}`,
+        activityType,
+        timestamp: new Date(Date.now() - Math.random() * 30 * 24 * 60 * 60 * 1000), // Within last 30 days
+        userInvolved: user._id,
+        changesMade: `${activityType} performed by ${user.profile.firstName} ${user.profile.lastName}`,
+        relatedObjects: [company._id.toString()],
+        companyId: company._id
+      };
+      
+      const activity = new Activity(activityData);
+      await activity.save();
+      
+      console.log(`  ✓ Created activity: ${activityType} for ${company.CompanyName}`);
     }
-    
-    console.log('🎉 Database seeding completed successfully!');
-  } catch (error) {
-    console.error('❌ Error seeding database:', error);
-    throw error;
   }
 }
 
-/**
- * Clear all collections in the database
- * DANGER: Only for development/testing environments
- * @returns {Promise<void>}
- */
-async function clearDatabase() {
-  try {
-    // Safety check to prevent accidental clearing of production data
-    if (process.env.NODE_ENV === 'production') {
-      throw new Error('Refusing to clear database in production environment');
+async function seedNotifications(users) {
+  console.log('🔔 Seeding notifications...');
+  
+  const notificationTypes = ['system', 'user-generated', 'reminder', 'alert'];
+  const titles = [
+    'Document requires signature',
+    'Financial report submitted',
+    'Stakeholder update available',
+    'System maintenance scheduled',
+    'New user joined company'
+  ];
+  
+  for (const user of users) {
+    for (let i = 0; i < SEED_CONFIG.notificationsPerUser; i++) {
+      const notificationType = notificationTypes[Math.floor(Math.random() * notificationTypes.length)];
+      const title = titles[Math.floor(Math.random() * titles.length)];
+      
+      const notificationData = {
+        notificationId: `NOTIF_${Date.now()}_${i}`,
+        notificationType,
+        title,
+        message: `${title} - This is a system generated notification for ${user.profile.firstName} ${user.profile.lastName}`,
+        recipient: user.email,
+        Timestamp: new Date(Date.now() - Math.random() * 7 * 24 * 60 * 60 * 1000), // Within last 7 days
+        RelatedObjects: user.companyId.toString(),
+        UserInvolved: user._id,
+        isRead: Math.random() > 0.5,
+        companyId: user.companyId
+      };
+      
+      const notification = new Notification(notificationData);
+      await notification.save();
+      
+      console.log(`  ✓ Created notification: ${title} for ${user.email}`);
     }
+  }
+}
+
+async function seedDocuments(companies, users) {
+  console.log('📄 Seeding documents...');
+  
+  const documentTypes = ['incorporation', 'shareholder_agreement', 'financial_report', 'legal_document', 'contract'];
+  const documentNames = [
+    'Articles of Incorporation',
+    'Shareholder Agreement',
+    'Employment Contract',
+    'Non-Disclosure Agreement',
+    'Financial Statement',
+    'Board Resolution',
+    'Stock Option Plan',
+    'Operating Agreement',
+    'Partnership Agreement',
+    'Compliance Report'
+  ];
+  
+  for (const company of companies) {
+    const companyUsers = users.filter(u => u.companyId.toString() === company._id.toString());
     
-    console.log('🧹 Clearing database collections...');
-    
-    // Get all collections and clear them
-    const collections = mongoose.connection.collections;
-    for (const key in collections) {
-      const collection = collections[key];
-      const result = await collection.deleteMany({});
-      console.log(`Cleared ${result.deletedCount} documents from ${key}`);
+    for (let i = 0; i < SEED_CONFIG.documentsPerCompany; i++) {
+      const documentType = documentTypes[Math.floor(Math.random() * documentTypes.length)];
+      const documentName = documentNames[Math.floor(Math.random() * documentNames.length)];
+      const creator = companyUsers[Math.floor(Math.random() * companyUsers.length)];
+      
+      const documentData = {
+        title: `${documentName} - ${company.CompanyName}`,
+        fileName: `${documentName.toLowerCase().replace(/\\s+/g, '_')}_${company.CompanyName.toLowerCase().replace(/\\s+/g, '_')}.pdf`,
+        fileType: 'application/pdf',
+        fileSize: Math.floor(Math.random() * 5000000) + 100000, // 100KB to 5MB
+        category: documentType,
+        description: `${documentName} for ${company.CompanyName}`,
+        tags: [documentType, company.CompanyType.toLowerCase(), 'legal'],
+        uploadedBy: creator._id,
+        companyId: company._id,
+        accessLevel: Math.random() > 0.5 ? 'public' : 'private',
+        status: Math.random() > 0.8 ? 'pending' : 'approved',
+        version: '1.0',
+        createdAt: new Date(Date.now() - Math.random() * 60 * 24 * 60 * 60 * 1000), // Within last 60 days
+        updatedAt: new Date()
+      };
+      
+      const document = new Document(documentData);
+      await document.save();
+      
+      console.log(`  ✓ Created document: ${documentData.title}`);
     }
-    
-    console.log('✅ Database cleared successfully');
-  } catch (error) {
-    console.error('❌ Error clearing database:', error);
-    throw error;
   }
 }
 
-// Direct script execution
+// Helper functions for generating realistic data
+function getRandomFirstName() {
+  const names = ['Alex', 'Jordan', 'Taylor', 'Morgan', 'Casey', 'Riley', 'Avery', 'Quinn', 'Sage', 'River'];
+  return names[Math.floor(Math.random() * names.length)];
+}
+
+function getRandomLastName() {
+  const names = ['Smith', 'Johnson', 'Williams', 'Brown', 'Jones', 'Garcia', 'Miller', 'Davis', 'Rodriguez', 'Martinez'];
+  return names[Math.floor(Math.random() * names.length)];
+}
+
+function generatePhoneNumber() {
+  const area = Math.floor(Math.random() * 700) + 200;
+  const exchange = Math.floor(Math.random() * 700) + 200;
+  const number = Math.floor(Math.random() * 9000) + 1000;
+  return `+1-${area}-${exchange}-${number}`;
+}
+
+function getRandomJobTitle() {
+  const titles = ['Software Engineer', 'Product Manager', 'Data Scientist', 'Marketing Manager', 'Sales Director', 'Operations Manager', 'CTO', 'CFO', 'VP Engineering', 'Business Analyst'];
+  return titles[Math.floor(Math.random() * titles.length)];
+}
+
+function getRandomDepartment() {
+  const departments = ['Engineering', 'Product', 'Marketing', 'Sales', 'Operations', 'Finance', 'Legal', 'Human Resources', 'Business Development'];
+  return departments[Math.floor(Math.random() * departments.length)];
+}
+
+function getRandomCity() {
+  const cities = ['San Francisco', 'New York', 'Austin', 'Seattle', 'Boston', 'Los Angeles', 'Chicago', 'Denver', 'Miami', 'Atlanta'];
+  return cities[Math.floor(Math.random() * cities.length)];
+}
+
+function getRandomState() {
+  const states = ['CA', 'NY', 'TX', 'WA', 'MA', 'IL', 'CO', 'FL', 'GA', 'OR'];
+  return states[Math.floor(Math.random() * states.length)];
+}
+
+// Run the seeding script
 if (require.main === module) {
-  // Connect to database
-  mongoose.connect(process.env.MONGODB_URI)
-    .then(() => {
-      console.log('Connected to MongoDB');
-      return seedDatabase();
-    })
-    .then(() => {
-      console.log('Seed operation completed');
-      process.exit(0);
-    })
-    .catch(err => {
-      console.error('Error during seed operation:', err);
-      process.exit(1);
-    });
+  seedDatabase();
 }
 
-module.exports = { seedDatabase, clearDatabase, SAMPLE_DATA };
+module.exports = { seedDatabase };
\ No newline at end of file
diff --git a/services/memoryService.js b/services/memoryService.js
new file mode 100644
index 0000000..529113f
--- /dev/null
+++ b/services/memoryService.js
@@ -0,0 +1,534 @@
+/**
+ * Memory Service Layer
+ * 
+ * Provides session and workflow memory management for OpenCap
+ * using ZeroDB for user sessions, workflow states, and context tracking
+ */
+
+const zerodbService = require('./zerodbService');
+const { v4: uuidv4 } = require('uuid');
+
+class MemoryService {
+  constructor() {
+    this.sessionTimeoutMs = 30 * 60 * 1000; // 30 minutes
+    this.maxMemoryPerSession = 1000;
+    this.contextTypes = {
+      USER_SESSION: 'user_session',
+      WORKFLOW_STATE: 'workflow_state',
+      FORM_DATA: 'form_data',
+      NAVIGATION: 'navigation',
+      PREFERENCES: 'preferences',
+      CACHE: 'cache'
+    };
+  }
+  
+  /**
+   * Initialize memory service
+   * @param {string} token - JWT token for authentication
+   */
+  async initialize(token) {
+    try {
+      await zerodbService.initialize(token);
+      console.log('Memory service initialized successfully');
+    } catch (error) {
+      console.error('Failed to initialize memory service:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Create a new session
+   * @param {string} userId - User ID
+   * @param {Object} context - Session context
+   * @returns {string} Session ID
+   */
+  async createSession(userId, context = {}) {
+    try {
+      const sessionId = uuidv4();
+      
+      const sessionData = {
+        session_id: sessionId,
+        user_id: userId,
+        created_at: new Date().toISOString(),
+        last_activity: new Date().toISOString(),
+        context: {
+          user_agent: context.userAgent,
+          ip_address: context.ipAddress,
+          device_type: context.deviceType,
+          browser: context.browser
+        }
+      };
+      
+      await zerodbService.storeMemory(
+        `session:${sessionId}`,
+        sessionId,
+        'system',
+        JSON.stringify(sessionData),
+        {
+          type: this.contextTypes.USER_SESSION,
+          user_id: userId,
+          expires_at: new Date(Date.now() + this.sessionTimeoutMs).toISOString()
+        }
+      );
+      
+      console.log(`Session created: ${sessionId} for user ${userId}`);
+      return sessionId;
+    } catch (error) {
+      console.error('Error creating session:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Get session data
+   * @param {string} sessionId - Session ID
+   * @returns {Object} Session data
+   */
+  async getSession(sessionId) {
+    try {
+      const memories = await zerodbService.listMemory(
+        `session:${sessionId}`,
+        sessionId,
+        'system',
+        0,
+        1
+      );
+      
+      if (memories.length === 0) {
+        return null;
+      }
+      
+      const sessionMemory = memories[0];
+      const sessionData = JSON.parse(sessionMemory.content);
+      
+      // Check if session is expired
+      const expiresAt = new Date(sessionMemory.memory_metadata.expires_at);
+      if (expiresAt < new Date()) {
+        await this.expireSession(sessionId);
+        return null;
+      }
+      
+      return sessionData;
+    } catch (error) {
+      console.error('Error getting session:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Update session activity
+   * @param {string} sessionId - Session ID
+   * @param {Object} activity - Activity data
+   */
+  async updateSessionActivity(sessionId, activity = {}) {
+    try {
+      const sessionData = await this.getSession(sessionId);
+      if (!sessionData) {
+        throw new Error('Session not found or expired');
+      }
+      
+      sessionData.last_activity = new Date().toISOString();
+      sessionData.activity_count = (sessionData.activity_count || 0) + 1;
+      
+      if (activity.page) {
+        sessionData.current_page = activity.page;
+      }
+      
+      if (activity.feature) {
+        sessionData.last_feature = activity.feature;
+      }
+      
+      await zerodbService.storeMemory(
+        `session:${sessionId}`,
+        sessionId,
+        'system',
+        JSON.stringify(sessionData),
+        {
+          type: this.contextTypes.USER_SESSION,
+          user_id: sessionData.user_id,
+          expires_at: new Date(Date.now() + this.sessionTimeoutMs).toISOString()
+        }
+      );
+    } catch (error) {
+      console.error('Error updating session activity:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Store workflow state
+   * @param {string} workflowId - Workflow ID
+   * @param {string} sessionId - Session ID
+   * @param {string} currentState - Current workflow state
+   * @param {Object} stateData - State data
+   * @param {Object} context - Additional context
+   */
+  async storeWorkflowState(workflowId, sessionId, currentState, stateData, context = {}) {
+    try {
+      const workflowStateData = {
+        workflow_id: workflowId,
+        session_id: sessionId,
+        current_state: currentState,
+        state_data: stateData,
+        timestamp: new Date().toISOString(),
+        context
+      };
+      
+      await zerodbService.storeMemory(
+        `workflow:${workflowId}`,
+        sessionId,
+        'system',
+        JSON.stringify(workflowStateData),
+        {
+          type: this.contextTypes.WORKFLOW_STATE,
+          workflow_id: workflowId,
+          current_state: currentState,
+          user_id: context.userId
+        }
+      );
+      
+      console.log(`Workflow state stored: ${workflowId} - ${currentState}`);
+    } catch (error) {
+      console.error('Error storing workflow state:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Get workflow state
+   * @param {string} workflowId - Workflow ID
+   * @param {string} sessionId - Session ID
+   * @returns {Object} Workflow state data
+   */
+  async getWorkflowState(workflowId, sessionId) {
+    try {
+      const memories = await zerodbService.listMemory(
+        `workflow:${workflowId}`,
+        sessionId,
+        'system',
+        0,
+        1
+      );
+      
+      if (memories.length === 0) {
+        return null;
+      }
+      
+      const workflowMemory = memories[0];
+      return JSON.parse(workflowMemory.content);
+    } catch (error) {
+      console.error('Error getting workflow state:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Store form data
+   * @param {string} formId - Form ID
+   * @param {string} sessionId - Session ID
+   * @param {Object} formData - Form data
+   * @param {Object} metadata - Form metadata
+   */
+  async storeFormData(formId, sessionId, formData, metadata = {}) {
+    try {
+      const formDataRecord = {
+        form_id: formId,
+        session_id: sessionId,
+        form_data: formData,
+        saved_at: new Date().toISOString(),
+        metadata
+      };
+      
+      await zerodbService.storeMemory(
+        `form:${formId}`,
+        sessionId,
+        'user',
+        JSON.stringify(formDataRecord),
+        {
+          type: this.contextTypes.FORM_DATA,
+          form_id: formId,
+          field_count: Object.keys(formData).length
+        }
+      );
+      
+      console.log(`Form data stored: ${formId}`);
+    } catch (error) {
+      console.error('Error storing form data:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Get form data
+   * @param {string} formId - Form ID
+   * @param {string} sessionId - Session ID
+   * @returns {Object} Form data
+   */
+  async getFormData(formId, sessionId) {
+    try {
+      const memories = await zerodbService.listMemory(
+        `form:${formId}`,
+        sessionId,
+        'user',
+        0,
+        1
+      );
+      
+      if (memories.length === 0) {
+        return null;
+      }
+      
+      const formMemory = memories[0];
+      return JSON.parse(formMemory.content);
+    } catch (error) {
+      console.error('Error getting form data:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Store user preferences
+   * @param {string} userId - User ID
+   * @param {Object} preferences - User preferences
+   */
+  async storeUserPreferences(userId, preferences) {
+    try {
+      const preferencesData = {
+        user_id: userId,
+        preferences,
+        updated_at: new Date().toISOString()
+      };
+      
+      await zerodbService.storeMemory(
+        `preferences:${userId}`,
+        uuidv4(),
+        'system',
+        JSON.stringify(preferencesData),
+        {
+          type: this.contextTypes.PREFERENCES,
+          user_id: userId,
+          preference_count: Object.keys(preferences).length
+        }
+      );
+      
+      console.log(`User preferences stored: ${userId}`);
+    } catch (error) {
+      console.error('Error storing user preferences:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Get user preferences
+   * @param {string} userId - User ID
+   * @returns {Object} User preferences
+   */
+  async getUserPreferences(userId) {
+    try {
+      const memories = await zerodbService.listMemory(
+        `preferences:${userId}`,
+        null,
+        'system',
+        0,
+        1
+      );
+      
+      if (memories.length === 0) {
+        return {};
+      }
+      
+      const preferencesMemory = memories[0];
+      const preferencesData = JSON.parse(preferencesMemory.content);
+      return preferencesData.preferences || {};
+    } catch (error) {
+      console.error('Error getting user preferences:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Store navigation history
+   * @param {string} sessionId - Session ID
+   * @param {string} fromPage - Previous page
+   * @param {string} toPage - Current page
+   * @param {Object} context - Navigation context
+   */
+  async storeNavigationHistory(sessionId, fromPage, toPage, context = {}) {
+    try {
+      const navigationData = {
+        session_id: sessionId,
+        from_page: fromPage,
+        to_page: toPage,
+        timestamp: new Date().toISOString(),
+        context
+      };
+      
+      await zerodbService.storeMemory(
+        `navigation:${sessionId}`,
+        sessionId,
+        'system',
+        JSON.stringify(navigationData),
+        {
+          type: this.contextTypes.NAVIGATION,
+          from_page: fromPage,
+          to_page: toPage
+        }
+      );
+    } catch (error) {
+      console.error('Error storing navigation history:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Get navigation history
+   * @param {string} sessionId - Session ID
+   * @param {number} limit - Maximum records to return
+   * @returns {Array} Navigation history
+   */
+  async getNavigationHistory(sessionId, limit = 50) {
+    try {
+      const memories = await zerodbService.listMemory(
+        `navigation:${sessionId}`,
+        sessionId,
+        'system',
+        0,
+        limit
+      );
+      
+      return memories.map(memory => JSON.parse(memory.content));
+    } catch (error) {
+      console.error('Error getting navigation history:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Cache data
+   * @param {string} key - Cache key
+   * @param {any} data - Data to cache
+   * @param {number} ttlMs - Time to live in milliseconds
+   */
+  async cacheData(key, data, ttlMs = 5 * 60 * 1000) {
+    try {
+      const cacheData = {
+        key,
+        data,
+        cached_at: new Date().toISOString(),
+        expires_at: new Date(Date.now() + ttlMs).toISOString()
+      };
+      
+      await zerodbService.storeMemory(
+        `cache:${key}`,
+        uuidv4(),
+        'system',
+        JSON.stringify(cacheData),
+        {
+          type: this.contextTypes.CACHE,
+          cache_key: key,
+          expires_at: cacheData.expires_at
+        }
+      );
+    } catch (error) {
+      console.error('Error caching data:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Get cached data
+   * @param {string} key - Cache key
+   * @returns {any} Cached data or null if not found/expired
+   */
+  async getCachedData(key) {
+    try {
+      const memories = await zerodbService.listMemory(
+        `cache:${key}`,
+        null,
+        'system',
+        0,
+        1
+      );
+      
+      if (memories.length === 0) {
+        return null;
+      }
+      
+      const cacheMemory = memories[0];
+      const cacheData = JSON.parse(cacheMemory.content);
+      
+      // Check if cache is expired
+      if (new Date(cacheData.expires_at) < new Date()) {
+        return null;
+      }
+      
+      return cacheData.data;
+    } catch (error) {
+      console.error('Error getting cached data:', error);
+      return null;
+    }
+  }
+  
+  /**
+   * Expire session
+   * @param {string} sessionId - Session ID
+   */
+  async expireSession(sessionId) {
+    try {
+      // Note: ZeroDB doesn't have delete functionality in the documented API
+      // This would need to be implemented when delete functionality is available
+      console.log(`Session expired: ${sessionId}`);
+    } catch (error) {
+      console.error('Error expiring session:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Get memory analytics
+   * @param {string} type - Memory type to analyze
+   * @returns {Object} Memory analytics
+   */
+  async getMemoryAnalytics(type) {
+    try {
+      // This would need to be implemented with proper filtering
+      // when ZeroDB provides better query capabilities
+      const memories = await zerodbService.listMemory(null, null, null, 0, 1000);
+      
+      const filteredMemories = memories.filter(memory => 
+        memory.memory_metadata?.type === type
+      );
+      
+      return {
+        type,
+        total_records: filteredMemories.length,
+        memory_usage: filteredMemories.reduce((sum, memory) => 
+          sum + (memory.content ? memory.content.length : 0), 0
+        ),
+        oldest_record: filteredMemories.length > 0 ? 
+          filteredMemories[filteredMemories.length - 1].created_at : null,
+        newest_record: filteredMemories.length > 0 ? 
+          filteredMemories[0].created_at : null
+      };
+    } catch (error) {
+      console.error('Error getting memory analytics:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Cleanup expired memories
+   */
+  async cleanupExpiredMemories() {
+    try {
+      // This would need to be implemented when ZeroDB provides delete functionality
+      console.log('Memory cleanup not implemented - waiting for ZeroDB delete API');
+    } catch (error) {
+      console.error('Error cleaning up expired memories:', error);
+      throw error;
+    }
+  }
+}
+
+// Export singleton instance
+module.exports = new MemoryService();
\ No newline at end of file
diff --git a/services/streamingService.js b/services/streamingService.js
new file mode 100644
index 0000000..b4823f7
--- /dev/null
+++ b/services/streamingService.js
@@ -0,0 +1,490 @@
+/**
+ * Streaming Service Layer
+ * 
+ * Provides real-time event streaming functionality for OpenCap
+ * using ZeroDB for financial transactions, user activities, and workflows
+ */
+
+const zerodbService = require('./zerodbService');
+const { EventEmitter } = require('events');
+
+class StreamingService extends EventEmitter {
+  constructor() {
+    super();
+    this.topics = {
+      FINANCIAL_TRANSACTION: 'financial_transaction',
+      USER_ACTIVITY: 'user_activity', 
+      DOCUMENT_ACTIVITY: 'document_activity',
+      COMPLIANCE_EVENT: 'compliance_event',
+      WORKFLOW_STATE: 'workflow_state',
+      SYSTEM_ALERT: 'system_alert',
+      SPV_ACTIVITY: 'spv_activity',
+      NOTIFICATION: 'notification'
+    };
+    
+    this.eventBuffer = [];
+    this.maxBufferSize = 1000;
+    this.batchSize = 10;
+    this.flushInterval = 5000; // 5 seconds
+    
+    // Start batch processing
+    this.startBatchProcessing();
+  }
+  
+  /**
+   * Initialize streaming service
+   * @param {string} token - JWT token for authentication
+   */
+  async initialize(token) {
+    try {
+      await zerodbService.initialize(token);
+      console.log('Streaming service initialized successfully');
+    } catch (error) {
+      console.error('Failed to initialize streaming service:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Publish financial transaction event
+   * @param {Object} transaction - Transaction data
+   * @param {string} userId - User ID
+   * @returns {Object} Published event
+   */
+  async publishFinancialTransaction(transaction, userId) {
+    const eventPayload = {
+      transaction_id: transaction.id,
+      user_id: userId,
+      type: transaction.type,
+      amount: transaction.amount,
+      currency: transaction.currency,
+      timestamp: new Date().toISOString(),
+      metadata: {
+        company_id: transaction.companyId,
+        category: transaction.category,
+        status: transaction.status
+      }
+    };
+    
+    return this.publishEvent(this.topics.FINANCIAL_TRANSACTION, eventPayload);
+  }
+  
+  /**
+   * Publish user activity event
+   * @param {string} userId - User ID
+   * @param {string} action - Action performed
+   * @param {Object} context - Activity context
+   * @returns {Object} Published event
+   */
+  async publishUserActivity(userId, action, context = {}) {
+    const eventPayload = {
+      user_id: userId,
+      action,
+      timestamp: new Date().toISOString(),
+      session_id: context.sessionId,
+      ip_address: context.ipAddress,
+      user_agent: context.userAgent,
+      metadata: {
+        page: context.page,
+        feature: context.feature,
+        duration_ms: context.duration,
+        success: context.success !== false
+      }
+    };
+    
+    return this.publishEvent(this.topics.USER_ACTIVITY, eventPayload);
+  }
+  
+  /**
+   * Publish document activity event
+   * @param {string} documentId - Document ID
+   * @param {string} userId - User ID
+   * @param {string} action - Action performed (view, edit, delete, share)
+   * @param {Object} metadata - Additional metadata
+   * @returns {Object} Published event
+   */
+  async publishDocumentActivity(documentId, userId, action, metadata = {}) {
+    const eventPayload = {
+      document_id: documentId,
+      user_id: userId,
+      action,
+      timestamp: new Date().toISOString(),
+      metadata: {
+        document_type: metadata.documentType,
+        file_size: metadata.fileSize,
+        access_level: metadata.accessLevel,
+        ...metadata
+      }
+    };
+    
+    return this.publishEvent(this.topics.DOCUMENT_ACTIVITY, eventPayload);
+  }
+  
+  /**
+   * Publish compliance event
+   * @param {string} complianceId - Compliance check ID
+   * @param {string} status - Compliance status (passed, failed, warning)
+   * @param {Object} details - Compliance details
+   * @returns {Object} Published event
+   */
+  async publishComplianceEvent(complianceId, status, details = {}) {
+    const eventPayload = {
+      compliance_id: complianceId,
+      status,
+      timestamp: new Date().toISOString(),
+      severity: details.severity || 'medium',
+      rule_id: details.ruleId,
+      entity_type: details.entityType,
+      entity_id: details.entityId,
+      metadata: {
+        score: details.score,
+        violations: details.violations,
+        recommendations: details.recommendations
+      }
+    };
+    
+    return this.publishEvent(this.topics.COMPLIANCE_EVENT, eventPayload);
+  }
+  
+  /**
+   * Publish workflow state change event
+   * @param {string} workflowId - Workflow ID
+   * @param {string} fromState - Previous state
+   * @param {string} toState - New state
+   * @param {string} userId - User who triggered the change
+   * @param {Object} context - Additional context
+   * @returns {Object} Published event
+   */
+  async publishWorkflowStateChange(workflowId, fromState, toState, userId, context = {}) {
+    const eventPayload = {
+      workflow_id: workflowId,
+      from_state: fromState,
+      to_state: toState,
+      user_id: userId,
+      timestamp: new Date().toISOString(),
+      metadata: {
+        workflow_type: context.workflowType,
+        entity_id: context.entityId,
+        reason: context.reason,
+        automatic: context.automatic || false
+      }
+    };
+    
+    return this.publishEvent(this.topics.WORKFLOW_STATE, eventPayload);
+  }
+  
+  /**
+   * Publish SPV activity event
+   * @param {string} spvId - SPV ID
+   * @param {string} activity - Activity type
+   * @param {string} userId - User ID
+   * @param {Object} details - Activity details
+   * @returns {Object} Published event
+   */
+  async publishSPVActivity(spvId, activity, userId, details = {}) {
+    const eventPayload = {
+      spv_id: spvId,
+      activity,
+      user_id: userId,
+      timestamp: new Date().toISOString(),
+      metadata: {
+        amount: details.amount,
+        currency: details.currency,
+        investor_count: details.investorCount,
+        status: details.status,
+        ...details
+      }
+    };
+    
+    return this.publishEvent(this.topics.SPV_ACTIVITY, eventPayload);
+  }
+  
+  /**
+   * Publish system alert
+   * @param {string} alertType - Alert type
+   * @param {string} severity - Alert severity (low, medium, high, critical)
+   * @param {string} message - Alert message
+   * @param {Object} context - Alert context
+   * @returns {Object} Published event
+   */
+  async publishSystemAlert(alertType, severity, message, context = {}) {
+    const eventPayload = {
+      alert_type: alertType,
+      severity,
+      message,
+      timestamp: new Date().toISOString(),
+      metadata: {
+        component: context.component,
+        error_code: context.errorCode,
+        affected_users: context.affectedUsers,
+        resolution_steps: context.resolutionSteps
+      }
+    };
+    
+    return this.publishEvent(this.topics.SYSTEM_ALERT, eventPayload);
+  }
+  
+  /**
+   * Publish notification event
+   * @param {string} userId - Target user ID
+   * @param {string} type - Notification type
+   * @param {string} title - Notification title
+   * @param {string} message - Notification message
+   * @param {Object} metadata - Additional metadata
+   * @returns {Object} Published event
+   */
+  async publishNotification(userId, type, title, message, metadata = {}) {
+    const eventPayload = {
+      user_id: userId,
+      type,
+      title,
+      message,
+      timestamp: new Date().toISOString(),
+      metadata: {
+        priority: metadata.priority || 'normal',
+        category: metadata.category,
+        action_url: metadata.actionUrl,
+        expires_at: metadata.expiresAt
+      }
+    };
+    
+    return this.publishEvent(this.topics.NOTIFICATION, eventPayload);
+  }
+  
+  /**
+   * Publish event to ZeroDB
+   * @param {string} topic - Event topic
+   * @param {Object} eventPayload - Event data
+   * @param {boolean} batch - Whether to batch the event
+   * @returns {Object} Published event
+   */
+  async publishEvent(topic, eventPayload, batch = true) {
+    try {
+      if (batch) {
+        // Add to buffer for batch processing
+        this.eventBuffer.push({ topic, eventPayload, timestamp: Date.now() });
+        
+        // Trim buffer if it exceeds max size
+        if (this.eventBuffer.length > this.maxBufferSize) {
+          this.eventBuffer = this.eventBuffer.slice(-this.maxBufferSize);
+        }
+        
+        // Emit local event for immediate processing
+        this.emit('event', { topic, eventPayload });
+        
+        return { status: 'buffered', topic, timestamp: eventPayload.timestamp };
+      } else {
+        // Publish immediately
+        const result = await zerodbService.publishEvent(topic, eventPayload);
+        
+        // Emit local event
+        this.emit('event', { topic, eventPayload, published: true });
+        
+        return result;
+      }
+    } catch (error) {
+      console.error('Error publishing event:', error);
+      
+      // Emit error event
+      this.emit('error', { error, topic, eventPayload });
+      
+      throw error;
+    }
+  }
+  
+  /**
+   * Start batch processing of events
+   */
+  startBatchProcessing() {
+    setInterval(async () => {
+      await this.flushEventBuffer();
+    }, this.flushInterval);
+  }
+  
+  /**
+   * Flush event buffer to ZeroDB
+   */
+  async flushEventBuffer() {
+    if (this.eventBuffer.length === 0) {
+      return;
+    }
+    
+    const eventsToFlush = this.eventBuffer.splice(0, this.batchSize);
+    
+    try {
+      const publishPromises = eventsToFlush.map(event =>
+        zerodbService.publishEvent(event.topic, event.eventPayload)
+      );
+      
+      const results = await Promise.allSettled(publishPromises);
+      
+      let successCount = 0;
+      let failureCount = 0;
+      
+      results.forEach((result, index) => {
+        if (result.status === 'fulfilled') {
+          successCount++;
+          this.emit('event', {
+            ...eventsToFlush[index],
+            published: true,
+            result: result.value
+          });
+        } else {
+          failureCount++;
+          // Put failed events back in buffer for retry
+          this.eventBuffer.unshift(eventsToFlush[index]);
+          
+          this.emit('error', {
+            error: result.reason,
+            event: eventsToFlush[index]
+          });
+        }
+      });
+      
+      if (successCount > 0) {
+        console.log(`Flushed ${successCount} events successfully`);
+      }
+      
+      if (failureCount > 0) {
+        console.warn(`Failed to flush ${failureCount} events, retrying later`);
+      }
+    } catch (error) {
+      console.error('Error flushing event buffer:', error);
+      
+      // Put events back in buffer for retry
+      this.eventBuffer.unshift(...eventsToFlush);
+    }
+  }
+  
+  /**
+   * Get events by topic
+   * @param {string} topic - Event topic
+   * @param {number} limit - Maximum events to return
+   * @param {number} skip - Number of events to skip
+   * @returns {Array} List of events
+   */
+  async getEvents(topic, limit = 100, skip = 0) {
+    try {
+      return await zerodbService.listEvents(topic, skip, limit);
+    } catch (error) {
+      console.error('Error getting events:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Get real-time analytics
+   * @param {string} topic - Topic to analyze
+   * @param {string} timeRange - Time range (1h, 24h, 7d, 30d)
+   * @returns {Object} Analytics data
+   */
+  async getAnalytics(topic, timeRange = '24h') {
+    try {
+      const events = await this.getEvents(topic, 1000);
+      
+      const now = new Date();
+      const timeRanges = {
+        '1h': 60 * 60 * 1000,
+        '24h': 24 * 60 * 60 * 1000,
+        '7d': 7 * 24 * 60 * 60 * 1000,
+        '30d': 30 * 24 * 60 * 60 * 1000
+      };
+      
+      const cutoff = new Date(now.getTime() - timeRanges[timeRange]);
+      
+      const filteredEvents = events.filter(event => 
+        new Date(event.published_at) >= cutoff
+      );
+      
+      return {
+        topic,
+        time_range: timeRange,
+        total_events: filteredEvents.length,
+        events_per_hour: this.calculateEventsPerHour(filteredEvents),
+        top_users: this.getTopUsers(filteredEvents),
+        event_distribution: this.getEventDistribution(filteredEvents)
+      };
+    } catch (error) {
+      console.error('Error getting analytics:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Calculate events per hour
+   * @param {Array} events - Events to analyze
+   * @returns {Object} Events per hour data
+   */
+  calculateEventsPerHour(events) {
+    const hourlyData = {};
+    
+    events.forEach(event => {
+      const hour = new Date(event.published_at).toISOString().substring(0, 13);
+      hourlyData[hour] = (hourlyData[hour] || 0) + 1;
+    });
+    
+    return hourlyData;
+  }
+  
+  /**
+   * Get top users by event count
+   * @param {Array} events - Events to analyze
+   * @returns {Array} Top users
+   */
+  getTopUsers(events) {
+    const userCounts = {};
+    
+    events.forEach(event => {
+      const userId = event.event_payload?.user_id;
+      if (userId) {
+        userCounts[userId] = (userCounts[userId] || 0) + 1;
+      }
+    });
+    
+    return Object.entries(userCounts)
+      .sort(([,a], [,b]) => b - a)
+      .slice(0, 10)
+      .map(([userId, count]) => ({ user_id: userId, event_count: count }));
+  }
+  
+  /**
+   * Get event distribution by type/action
+   * @param {Array} events - Events to analyze
+   * @returns {Object} Event distribution
+   */
+  getEventDistribution(events) {
+    const distribution = {};
+    
+    events.forEach(event => {
+      const action = event.event_payload?.action || event.event_payload?.type || 'unknown';
+      distribution[action] = (distribution[action] || 0) + 1;
+    });
+    
+    return distribution;
+  }
+  
+  /**
+   * Force flush all buffered events
+   */
+  async forceFlush() {
+    while (this.eventBuffer.length > 0) {
+      await this.flushEventBuffer();
+    }
+  }
+  
+  /**
+   * Get buffer status
+   * @returns {Object} Buffer status
+   */
+  getBufferStatus() {
+    return {
+      buffered_events: this.eventBuffer.length,
+      max_buffer_size: this.maxBufferSize,
+      batch_size: this.batchSize,
+      flush_interval_ms: this.flushInterval
+    };
+  }
+}
+
+// Export singleton instance
+module.exports = new StreamingService();
\ No newline at end of file
diff --git a/services/vectorService.js b/services/vectorService.js
new file mode 100644
index 0000000..db6f335
--- /dev/null
+++ b/services/vectorService.js
@@ -0,0 +1,349 @@
+/**
+ * Vector Service Layer
+ * 
+ * Provides vector search and embedding functionality for OpenCap
+ * using ZeroDB for document search, compliance checking, and analytics
+ */
+
+const zerodbService = require('./zerodbService');
+const { v4: uuidv4 } = require('uuid');
+
+class VectorService {
+  constructor() {
+    this.documentNamespace = 'documents';
+    this.complianceNamespace = 'compliance';
+    this.financialNamespace = 'financial';
+    this.userNamespace = 'users';
+  }
+  
+  /**
+   * Initialize vector service
+   * @param {string} token - JWT token for authentication
+   */
+  async initialize(token) {
+    try {
+      await zerodbService.initialize(token);
+      console.log('Vector service initialized successfully');
+    } catch (error) {
+      console.error('Failed to initialize vector service:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Generate embedding for text (placeholder - would integrate with actual embedding service)
+   * @param {string} text - Text to embed
+   * @returns {Array} Vector embedding
+   */
+  async generateEmbedding(text) {
+    // Placeholder implementation - in production would use OpenAI, Cohere, etc.
+    // For now, generate a simple hash-based vector
+    const hash = this.simpleHash(text);
+    const embedding = [];
+    
+    // Generate 768-dimensional vector (common for sentence transformers)
+    for (let i = 0; i < 768; i++) {
+      embedding.push(Math.sin(hash * (i + 1)) * 0.1);
+    }
+    
+    return embedding;
+  }
+  
+  /**
+   * Simple hash function for demo purposes
+   * @param {string} str - Input string
+   * @returns {number} Hash value
+   */
+  simpleHash(str) {
+    let hash = 0;
+    if (str.length === 0) return hash;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = ((hash << 5) - hash) + char;
+      hash = hash & hash; // Convert to 32-bit integer
+    }
+    return hash;
+  }
+  
+  /**
+   * Index a document with vector embedding
+   * @param {string} documentId - Document identifier
+   * @param {string} title - Document title
+   * @param {string} content - Document content
+   * @param {string} type - Document type (financial_report, compliance_doc, etc.)
+   * @param {Object} metadata - Additional metadata
+   * @returns {Object} Indexed document details
+   */
+  async indexDocument(documentId, title, content, type, metadata = {}) {
+    try {
+      // Generate embedding for document content
+      const embedding = await this.generateEmbedding(content);
+      
+      // Prepare metadata
+      const vectorMetadata = {
+        document_id: documentId,
+        title,
+        type,
+        indexed_at: new Date().toISOString(),
+        ...metadata
+      };
+      
+      // Store in appropriate namespace based on type
+      let namespace = this.documentNamespace;
+      if (type === 'compliance_document') {
+        namespace = this.complianceNamespace;
+      } else if (type === 'financial_report') {
+        namespace = this.financialNamespace;
+      }
+      
+      const result = await zerodbService.upsertVector(
+        embedding,
+        namespace,
+        vectorMetadata,
+        content,
+        `document:${documentId}`
+      );
+      
+      console.log(`Document indexed successfully: ${documentId}`);
+      return result;
+    } catch (error) {
+      console.error('Error indexing document:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Search for similar documents
+   * @param {string} queryText - Search query
+   * @param {string} namespace - Search namespace
+   * @param {number} limit - Maximum results
+   * @param {Object} filters - Additional filters
+   * @returns {Object} Search results
+   */
+  async searchDocuments(queryText, namespace = this.documentNamespace, limit = 10, filters = {}) {
+    try {
+      // Generate embedding for query
+      const queryEmbedding = await this.generateEmbedding(queryText);
+      
+      // Search vectors
+      const results = await zerodbService.searchVectors(queryEmbedding, limit, namespace);
+      
+      // Filter results based on additional criteria
+      let filteredResults = results.vectors || [];
+      
+      if (filters.type) {
+        filteredResults = filteredResults.filter(v => 
+          v.vector_metadata?.type === filters.type
+        );
+      }
+      
+      if (filters.dateRange) {
+        filteredResults = filteredResults.filter(v => {
+          const indexedAt = new Date(v.vector_metadata?.indexed_at);
+          return indexedAt >= filters.dateRange.start && indexedAt <= filters.dateRange.end;
+        });
+      }
+      
+      return {
+        query: queryText,
+        results: filteredResults,
+        total_count: filteredResults.length,
+        search_time_ms: results.search_time_ms || 0
+      };
+    } catch (error) {
+      console.error('Error searching documents:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Search financial documents
+   * @param {string} queryText - Search query
+   * @param {number} limit - Maximum results
+   * @param {Object} filters - Additional filters
+   * @returns {Object} Search results
+   */
+  async searchFinancialDocuments(queryText, limit = 10, filters = {}) {
+    return this.searchDocuments(queryText, this.financialNamespace, limit, filters);
+  }
+  
+  /**
+   * Search compliance documents
+   * @param {string} queryText - Search query
+   * @param {number} limit - Maximum results
+   * @param {Object} filters - Additional filters
+   * @returns {Object} Search results
+   */
+  async searchComplianceDocuments(queryText, limit = 10, filters = {}) {
+    return this.searchDocuments(queryText, this.complianceNamespace, limit, filters);
+  }
+  
+  /**
+   * Find similar documents to a given document
+   * @param {string} documentId - Source document ID
+   * @param {number} limit - Maximum results
+   * @returns {Object} Similar documents
+   */
+  async findSimilarDocuments(documentId, limit = 5) {
+    try {
+      // Get all vectors to find the source document
+      const allVectors = await zerodbService.listVectors(this.documentNamespace, 0, 1000);
+      
+      const sourceDoc = allVectors.find(v => 
+        v.vector_metadata?.document_id === documentId
+      );
+      
+      if (!sourceDoc) {
+        throw new Error(`Document ${documentId} not found in vector database`);
+      }
+      
+      // Search for similar documents using the source document's embedding
+      const results = await zerodbService.searchVectors(
+        sourceDoc.vector_embedding,
+        limit + 1, // +1 to exclude the source document
+        this.documentNamespace
+      );
+      
+      // Remove the source document from results
+      const similarDocs = (results.vectors || []).filter(v => 
+        v.vector_metadata?.document_id !== documentId
+      );
+      
+      return {
+        source_document_id: documentId,
+        similar_documents: similarDocs.slice(0, limit),
+        total_count: similarDocs.length
+      };
+    } catch (error) {
+      console.error('Error finding similar documents:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Check document compliance using vector similarity
+   * @param {string} documentContent - Document content to check
+   * @param {Array} complianceRules - Compliance rules to check against
+   * @returns {Object} Compliance check results
+   */
+  async checkCompliance(documentContent, complianceRules = []) {
+    try {
+      const complianceResults = [];
+      
+      for (const rule of complianceRules) {
+        const searchResult = await this.searchComplianceDocuments(
+          rule.query,
+          5,
+          { type: rule.type }
+        );
+        
+        complianceResults.push({
+          rule_id: rule.id,
+          rule_name: rule.name,
+          matches: searchResult.results.length,
+          top_matches: searchResult.results.slice(0, 3),
+          compliance_score: this.calculateComplianceScore(searchResult.results)
+        });
+      }
+      
+      return {
+        document_content: documentContent.substring(0, 200) + '...',
+        compliance_checks: complianceResults,
+        overall_compliance_score: this.calculateOverallComplianceScore(complianceResults)
+      };
+    } catch (error) {
+      console.error('Error checking compliance:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Calculate compliance score based on search results
+   * @param {Array} results - Search results
+   * @returns {number} Compliance score (0-1)
+   */
+  calculateComplianceScore(results) {
+    if (results.length === 0) return 0;
+    
+    // Simple scoring based on number of matches and their relevance
+    const scoreSum = results.reduce((sum, result) => {
+      // Assume higher similarity means better compliance
+      return sum + (result.similarity_score || 0.5);
+    }, 0);
+    
+    return Math.min(scoreSum / results.length, 1);
+  }
+  
+  /**
+   * Calculate overall compliance score
+   * @param {Array} complianceResults - Compliance check results
+   * @returns {number} Overall compliance score (0-1)
+   */
+  calculateOverallComplianceScore(complianceResults) {
+    if (complianceResults.length === 0) return 0;
+    
+    const scoreSum = complianceResults.reduce((sum, result) => {
+      return sum + result.compliance_score;
+    }, 0);
+    
+    return scoreSum / complianceResults.length;
+  }
+  
+  /**
+   * Get document analytics
+   * @param {string} namespace - Namespace to analyze
+   * @returns {Object} Analytics data
+   */
+  async getDocumentAnalytics(namespace = this.documentNamespace) {
+    try {
+      const vectors = await zerodbService.listVectors(namespace, 0, 1000);
+      
+      const analytics = {
+        total_documents: vectors.length,
+        document_types: {},
+        indexed_over_time: {},
+        average_embedding_dimension: 0
+      };
+      
+      vectors.forEach(vector => {
+        // Count by type
+        const type = vector.vector_metadata?.type || 'unknown';
+        analytics.document_types[type] = (analytics.document_types[type] || 0) + 1;
+        
+        // Count by date
+        const indexedDate = new Date(vector.created_at).toISOString().split('T')[0];
+        analytics.indexed_over_time[indexedDate] = (analytics.indexed_over_time[indexedDate] || 0) + 1;
+        
+        // Calculate average embedding dimension
+        if (vector.vector_embedding) {
+          analytics.average_embedding_dimension = vector.vector_embedding.length;
+        }
+      });
+      
+      return analytics;
+    } catch (error) {
+      console.error('Error getting document analytics:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Delete document from vector database
+   * @param {string} documentId - Document identifier
+   * @returns {boolean} Success status
+   */
+  async deleteDocument(documentId) {
+    try {
+      // Note: ZeroDB API doesn't have direct delete endpoint in the documentation
+      // This would need to be implemented when the delete functionality is available
+      console.warn('Document deletion not implemented in ZeroDB API yet');
+      return false;
+    } catch (error) {
+      console.error('Error deleting document:', error);
+      throw error;
+    }
+  }
+}
+
+// Export singleton instance
+module.exports = new VectorService();
\ No newline at end of file
diff --git a/services/zerodbService.js b/services/zerodbService.js
new file mode 100644
index 0000000..2d2a66f
--- /dev/null
+++ b/services/zerodbService.js
@@ -0,0 +1,426 @@
+/**
+ * ZeroDB Service Layer
+ * 
+ * Provides integration with ZeroDB API for lakehouse functionality
+ * including vector search, real-time streaming, and memory management
+ */
+
+const axios = require('axios');
+const config = require('../config');
+
+class ZeroDBService {
+  constructor() {
+    this.baseURL = 'https://api.ainative.studio/api/v1';
+    this.projectId = null;
+    this.token = null;
+    this.client = axios.create({
+      baseURL: this.baseURL,
+      timeout: 30000,
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+    
+    // Add request interceptor for authentication
+    this.client.interceptors.request.use(
+      (config) => {
+        if (this.token) {
+          config.headers.Authorization = `Bearer ${this.token}`;
+        }
+        return config;
+      },
+      (error) => Promise.reject(error)
+    );
+    
+    // Add response interceptor for error handling
+    this.client.interceptors.response.use(
+      (response) => response,
+      (error) => {
+        console.error('ZeroDB API Error:', error.response?.data || error.message);
+        return Promise.reject(error);
+      }
+    );
+  }
+  
+  /**
+   * Initialize ZeroDB service with authentication
+   * @param {string} token - JWT token for authentication
+   */
+  async initialize(token) {
+    this.token = token;
+    
+    try {
+      // Create or get OpenCap project
+      const project = await this.initializeProject();
+      this.projectId = project.id;
+      
+      // Check database status
+      const dbStatus = await this.getDatabaseStatus();
+      console.log('ZeroDB initialized successfully:', {
+        projectId: this.projectId,
+        databaseStatus: dbStatus
+      });
+      
+      return {
+        projectId: this.projectId,
+        databaseStatus: dbStatus
+      };
+    } catch (error) {
+      console.error('Failed to initialize ZeroDB:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Initialize OpenCap project in ZeroDB
+   * @returns {Object} Project details
+   */
+  async initializeProject() {
+    try {
+      // Check if OpenCap project already exists
+      const projects = await this.client.get('/projects/');
+      const existingProject = projects.data.find(p => p.name === 'OpenCap');
+      
+      if (existingProject) {
+        return existingProject;
+      }
+      
+      // Create new OpenCap project
+      const response = await this.client.post('/projects/', {
+        name: 'OpenCap',
+        description: 'OpenCap Financial Management System with Lakehouse Analytics'
+      });
+      
+      return response.data;
+    } catch (error) {
+      console.error('Error initializing project:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Get database status for the project
+   * @returns {Object} Database status
+   */
+  async getDatabaseStatus() {
+    try {
+      const response = await this.client.get(`/projects/${this.projectId}/database/status`);
+      return response.data;
+    } catch (error) {
+      console.error('Error getting database status:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Create a table in ZeroDB
+   * @param {string} tableName - Name of the table
+   * @param {Object} schemaDefinition - Table schema
+   * @returns {Object} Created table details
+   */
+  async createTable(tableName, schemaDefinition) {
+    try {
+      const response = await this.client.post(`/projects/${this.projectId}/database/tables`, {
+        table_name: tableName,
+        schema_definition: schemaDefinition
+      });
+      return response.data;
+    } catch (error) {
+      console.error('Error creating table:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * List all tables in the project
+   * @returns {Array} List of tables
+   */
+  async listTables() {
+    try {
+      const response = await this.client.get(`/projects/${this.projectId}/database/tables`);
+      return response.data;
+    } catch (error) {
+      console.error('Error listing tables:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Upsert a vector embedding
+   * @param {Array} vectorEmbedding - Vector embedding array
+   * @param {string} namespace - Vector namespace
+   * @param {Object} metadata - Vector metadata
+   * @param {string} document - Associated document text
+   * @param {string} source - Vector source
+   * @returns {Object} Vector details
+   */
+  async upsertVector(vectorEmbedding, namespace = 'default', metadata = {}, document = '', source = '') {
+    try {
+      const response = await this.client.post(`/projects/${this.projectId}/database/vectors/upsert`, {
+        vector_embedding: vectorEmbedding,
+        namespace,
+        vector_metadata: metadata,
+        document,
+        source
+      });
+      return response.data;
+    } catch (error) {
+      console.error('Error upserting vector:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Search vectors by similarity
+   * @param {Array} queryVector - Query vector for similarity search
+   * @param {number} limit - Maximum number of results
+   * @param {string} namespace - Search namespace
+   * @returns {Object} Search results
+   */
+  async searchVectors(queryVector, limit = 10, namespace = 'default') {
+    try {
+      const response = await this.client.post(`/projects/${this.projectId}/database/vectors/search`, {
+        query_vector: queryVector,
+        limit,
+        namespace
+      });
+      return response.data;
+    } catch (error) {
+      console.error('Error searching vectors:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * List vectors
+   * @param {string} namespace - Filter by namespace
+   * @param {number} skip - Number of records to skip
+   * @param {number} limit - Maximum records to return
+   * @returns {Array} List of vectors
+   */
+  async listVectors(namespace = 'default', skip = 0, limit = 100) {
+    try {
+      const response = await this.client.get(`/projects/${this.projectId}/database/vectors`, {
+        params: { namespace, skip, limit }
+      });
+      return response.data;
+    } catch (error) {
+      console.error('Error listing vectors:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Store memory record
+   * @param {string} agentId - Agent identifier
+   * @param {string} sessionId - Session identifier
+   * @param {string} role - Role (user/assistant/system)
+   * @param {string} content - Memory content
+   * @param {Object} metadata - Memory metadata
+   * @returns {Object} Memory record
+   */
+  async storeMemory(agentId, sessionId, role, content, metadata = {}) {
+    try {
+      const response = await this.client.post(`/projects/${this.projectId}/database/memory/store`, {
+        agent_id: agentId,
+        session_id: sessionId,
+        role,
+        content,
+        memory_metadata: metadata
+      });
+      return response.data;
+    } catch (error) {
+      console.error('Error storing memory:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * List memory records
+   * @param {string} agentId - Filter by agent
+   * @param {string} sessionId - Filter by session
+   * @param {string} role - Filter by role
+   * @param {number} skip - Number of records to skip
+   * @param {number} limit - Maximum records to return
+   * @returns {Array} List of memory records
+   */
+  async listMemory(agentId, sessionId, role, skip = 0, limit = 100) {
+    try {
+      const params = { skip, limit };
+      if (agentId) params.agent_id = agentId;
+      if (sessionId) params.session_id = sessionId;
+      if (role) params.role = role;
+      
+      const response = await this.client.get(`/projects/${this.projectId}/database/memory`, {
+        params
+      });
+      return response.data;
+    } catch (error) {
+      console.error('Error listing memory:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Publish event
+   * @param {string} topic - Event topic
+   * @param {Object} eventPayload - Event data
+   * @returns {Object} Published event
+   */
+  async publishEvent(topic, eventPayload) {
+    try {
+      const response = await this.client.post(`/projects/${this.projectId}/database/events/publish`, {
+        topic,
+        event_payload: eventPayload
+      });
+      return response.data;
+    } catch (error) {
+      console.error('Error publishing event:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * List events
+   * @param {string} topic - Filter by topic
+   * @param {number} skip - Number of records to skip
+   * @param {number} limit - Maximum records to return
+   * @returns {Array} List of events
+   */
+  async listEvents(topic, skip = 0, limit = 100) {
+    try {
+      const params = { skip, limit };
+      if (topic) params.topic = topic;
+      
+      const response = await this.client.get(`/projects/${this.projectId}/database/events`, {
+        params
+      });
+      return response.data;
+    } catch (error) {
+      console.error('Error listing events:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Upload file metadata
+   * @param {string} fileKey - File storage key
+   * @param {string} fileName - Original filename
+   * @param {string} contentType - MIME type
+   * @param {number} sizeBytes - File size
+   * @param {Object} metadata - File metadata
+   * @returns {Object} File record
+   */
+  async uploadFileMetadata(fileKey, fileName, contentType, sizeBytes, metadata = {}) {
+    try {
+      const response = await this.client.post(`/projects/${this.projectId}/database/files/upload`, {
+        file_key: fileKey,
+        file_name: fileName,
+        content_type: contentType,
+        size_bytes: sizeBytes,
+        file_metadata: metadata
+      });
+      return response.data;
+    } catch (error) {
+      console.error('Error uploading file metadata:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * List files
+   * @param {number} skip - Number of records to skip
+   * @param {number} limit - Maximum records to return
+   * @returns {Array} List of files
+   */
+  async listFiles(skip = 0, limit = 100) {
+    try {
+      const response = await this.client.get(`/projects/${this.projectId}/database/files`, {
+        params: { skip, limit }
+      });
+      return response.data;
+    } catch (error) {
+      console.error('Error listing files:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Log RLHF dataset
+   * @param {string} inputPrompt - Input prompt
+   * @param {string} modelOutput - Model output
+   * @param {string} sessionId - Session identifier
+   * @param {number} rewardScore - Reward score
+   * @param {string} notes - Feedback notes
+   * @returns {Object} RLHF dataset record
+   */
+  async logRLHF(inputPrompt, modelOutput, sessionId, rewardScore, notes = '') {
+    try {
+      const response = await this.client.post(`/projects/${this.projectId}/database/rlhf/log`, {
+        input_prompt: inputPrompt,
+        model_output: modelOutput,
+        session_id: sessionId,
+        reward_score: rewardScore,
+        notes
+      });
+      return response.data;
+    } catch (error) {
+      console.error('Error logging RLHF:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * Store agent log
+   * @param {string} agentId - Agent identifier
+   * @param {string} sessionId - Session identifier
+   * @param {string} logLevel - Log level
+   * @param {string} logMessage - Log message
+   * @param {Object} rawPayload - Additional log data
+   * @returns {Object} Agent log record
+   */
+  async storeAgentLog(agentId, sessionId, logLevel, logMessage, rawPayload = {}) {
+    try {
+      const response = await this.client.post(`/projects/${this.projectId}/database/agent/log`, {
+        agent_id: agentId,
+        session_id: sessionId,
+        log_level: logLevel,
+        log_message: logMessage,
+        raw_payload: rawPayload
+      });
+      return response.data;
+    } catch (error) {
+      console.error('Error storing agent log:', error);
+      throw error;
+    }
+  }
+  
+  /**
+   * List agent logs
+   * @param {string} agentId - Filter by agent
+   * @param {string} sessionId - Filter by session
+   * @param {string} logLevel - Filter by log level
+   * @param {number} skip - Number of records to skip
+   * @param {number} limit - Maximum records to return
+   * @returns {Array} List of agent logs
+   */
+  async listAgentLogs(agentId, sessionId, logLevel, skip = 0, limit = 100) {
+    try {
+      const params = { skip, limit };
+      if (agentId) params.agent_id = agentId;
+      if (sessionId) params.session_id = sessionId;
+      if (logLevel) params.log_level = logLevel;
+      
+      const response = await this.client.get(`/projects/${this.projectId}/database/agent/logs`, {
+        params
+      });
+      return response.data;
+    } catch (error) {
+      console.error('Error listing agent logs:', error);
+      throw error;
+    }
+  }
+}
+
+// Export singleton instance
+module.exports = new ZeroDBService();
\ No newline at end of file
diff --git a/start-backend.js b/start-backend.js
new file mode 100644
index 0000000..f6c125a
--- /dev/null
+++ b/start-backend.js
@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const path = require('path');
+
+console.log('🚀 Starting OpenCap Backend Server...');
+
+// Change to project directory
+process.chdir('/Volumes/Cody/projects/opencap-clean');
+
+// Start the backend server
+const backend = spawn('/opt/homebrew/bin/node', ['app.js'], {
+  stdio: 'inherit',
+  cwd: '/Volumes/Cody/projects/opencap-clean'
+});
+
+backend.on('error', (error) => {
+  console.error('❌ Failed to start backend server:', error);
+});
+
+backend.on('close', (code) => {
+  console.log(`Backend server exited with code ${code}`);
+});
+
+// Keep the process running
+process.on('SIGINT', () => {
+  console.log('\n🛑 Stopping backend server...');
+  backend.kill();
+  process.exit();
+});
+
+console.log('✅ Backend server starting...');
+console.log('📍 Backend will be available at: http://localhost:5000');
+console.log('📚 API docs will be at: http://localhost:5000/api-docs');
+console.log('\nPress Ctrl+C to stop the server');
\ No newline at end of file
diff --git a/start-frontend.js b/start-frontend.js
new file mode 100644
index 0000000..2535c44
--- /dev/null
+++ b/start-frontend.js
@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const path = require('path');
+
+console.log('🎨 Starting OpenCap Frontend Server...');
+
+// Change to frontend directory
+const frontendDir = '/Volumes/Cody/projects/opencap-clean/frontend';
+process.chdir(frontendDir);
+
+// Start the frontend development server
+const frontend = spawn('/opt/homebrew/bin/npm', ['run', 'dev'], {
+  stdio: 'inherit',
+  cwd: frontendDir,
+  env: { ...process.env, PATH: '/opt/homebrew/bin:' + process.env.PATH }
+});
+
+frontend.on('error', (error) => {
+  console.error('❌ Failed to start frontend server:', error);
+});
+
+frontend.on('close', (code) => {
+  console.log(`Frontend server exited with code ${code}`);
+});
+
+// Keep the process running
+process.on('SIGINT', () => {
+  console.log('\n🛑 Stopping frontend server...');
+  frontend.kill();
+  process.exit();
+});
+
+console.log('✅ Frontend server starting...');
+console.log('📍 Frontend will be available at: http://localhost:5173');
+console.log('\nPress Ctrl+C to stop the server');
\ No newline at end of file
diff --git a/start-servers.sh b/start-servers.sh
new file mode 100644
index 0000000..2f71200
--- /dev/null
+++ b/start-servers.sh
@@ -0,0 +1,53 @@
+#!/bin/bash
+
+echo "🚀 Starting OpenCap Backend and Frontend Servers..."
+
+# Check if Node.js is installed
+if ! command -v node &> /dev/null; then
+    echo "❌ Node.js is not installed. Please install Node.js version 18 or higher."
+    exit 1
+fi
+
+# Check Node.js version
+NODE_VERSION=$(node -v | cut -d'v' -f2 | cut -d'.' -f1)
+if [ "$NODE_VERSION" -lt 18 ]; then
+    echo "❌ Node.js version 18 or higher is required. Current version: $(node -v)"
+    exit 1
+fi
+
+echo "✅ Node.js version: $(node -v)"
+
+# Start backend server
+echo "🔧 Starting Backend Server..."
+cd /Volumes/Cody/projects/opencap-clean
+npm install > /dev/null 2>&1
+echo "Backend server starting on port 5000..."
+node app.js &
+BACKEND_PID=$!
+echo "✅ Backend server started with PID: $BACKEND_PID"
+
+# Wait a moment for backend to start
+sleep 3
+
+# Start frontend server
+echo "🔧 Starting Frontend Server..."
+cd /Volumes/Cody/projects/opencap-clean/frontend
+npm install > /dev/null 2>&1
+echo "Frontend server starting on port 5173..."
+npm run dev &
+FRONTEND_PID=$!
+echo "✅ Frontend server started with PID: $FRONTEND_PID"
+
+echo ""
+echo "🎉 Both servers are now running!"
+echo ""
+echo "📍 Backend API:  http://localhost:5000"
+echo "📍 Frontend App: http://localhost:5173"
+echo ""
+echo "💡 To stop the servers, run:"
+echo "   kill $BACKEND_PID $FRONTEND_PID"
+echo ""
+echo "🌐 Open your browser to http://localhost:5173 to see the application"
+
+# Keep script running
+wait
\ No newline at end of file
diff --git a/start_servers.py b/start_servers.py
new file mode 100644
index 0000000..b58dcb9
--- /dev/null
+++ b/start_servers.py
@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+
+import subprocess
+import os
+import time
+import signal
+import sys
+
+def start_servers():
+    print("🚀 Starting OpenCap Servers...")
+    
+    # Set environment
+    node_path = "/opt/homebrew/bin/node"
+    npm_path = "/opt/homebrew/bin/npm"
+    project_root = "/Volumes/Cody/projects/opencap-clean"
+    frontend_dir = os.path.join(project_root, "frontend")
+    
+    # Check if paths exist
+    if not os.path.exists(node_path):
+        print(f"❌ Node.js not found at {node_path}")
+        return
+    
+    if not os.path.exists(npm_path):
+        print(f"❌ npm not found at {npm_path}")
+        return
+        
+    if not os.path.exists(project_root):
+        print(f"❌ Project root not found at {project_root}")
+        return
+        
+    if not os.path.exists(frontend_dir):
+        print(f"❌ Frontend directory not found at {frontend_dir}")
+        return
+    
+    print("✅ All paths verified")
+    
+    # Start backend server
+    print("🔧 Starting backend server...")
+    try:
+        backend_process = subprocess.Popen(
+            [node_path, "app.js"],
+            cwd=project_root,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        print(f"✅ Backend started with PID: {backend_process.pid}")
+    except Exception as e:
+        print(f"❌ Failed to start backend: {e}")
+        return
+    
+    # Wait a moment for backend to start
+    time.sleep(3)
+    
+    # Start frontend server
+    print("🎨 Starting frontend server...")
+    try:
+        frontend_process = subprocess.Popen(
+            [npm_path, "run", "dev"],
+            cwd=frontend_dir,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            env={**os.environ, "PATH": "/opt/homebrew/bin:" + os.environ.get("PATH", "")}
+        )
+        print(f"✅ Frontend started with PID: {frontend_process.pid}")
+    except Exception as e:
+        print(f"❌ Failed to start frontend: {e}")
+        # Kill backend if frontend fails
+        backend_process.terminate()
+        return
+    
+    print("\n🎉 Both servers are now running!")
+    print("\n📍 Backend API:  http://localhost:5000")
+    print("📍 Frontend App: http://localhost:5173")
+    print("📚 API Docs:     http://localhost:5000/api-docs")
+    print("\n🌐 Open http://localhost:5173 in your browser!")
+    print("⏳ Give the servers 10-15 seconds to fully start up")
+    
+    # Function to handle shutdown
+    def signal_handler(sig, frame):
+        print("\n🛑 Shutting down servers...")
+        backend_process.terminate()
+        frontend_process.terminate()
+        
+        # Wait for processes to terminate
+        backend_process.wait(timeout=5)
+        frontend_process.wait(timeout=5)
+        
+        print("✅ Servers stopped!")
+        sys.exit(0)
+    
+    # Register signal handlers
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+    
+    # Monitor processes
+    try:
+        while True:
+            # Check if processes are still running
+            backend_status = backend_process.poll()
+            frontend_status = frontend_process.poll()
+            
+            if backend_status is not None:
+                print(f"❌ Backend process exited with code {backend_status}")
+                # Get error output
+                _, stderr = backend_process.communicate()
+                if stderr:
+                    print("Backend errors:", stderr)
+                break
+                
+            if frontend_status is not None:
+                print(f"❌ Frontend process exited with code {frontend_status}")
+                # Get error output
+                _, stderr = frontend_process.communicate()
+                if stderr:
+                    print("Frontend errors:", stderr)
+                break
+            
+            time.sleep(1)
+            
+    except KeyboardInterrupt:
+        signal_handler(signal.SIGINT, None)
+
+if __name__ == "__main__":
+    start_servers()
\ No newline at end of file
diff --git a/startup-love b/startup-love
new file mode 160000
index 0000000..cb11299
--- /dev/null
+++ b/startup-love
@@ -0,0 +1 @@
+Subproject commit cb11299e1e5b8f7876dd6e73f150844c292812a2
diff --git a/test-node.js b/test-node.js
new file mode 100644
index 0000000..be50427
--- /dev/null
+++ b/test-node.js
@@ -0,0 +1,30 @@
+console.log('✅ Node.js is working!');
+console.log('Node version:', process.version);
+console.log('Current directory:', process.cwd());
+
+// Try to start the backend server directly
+const path = require('path');
+const fs = require('fs');
+
+const projectRoot = '/Volumes/Cody/projects/opencap-clean';
+const appFile = path.join(projectRoot, 'app.js');
+
+console.log('Checking for app.js:', appFile);
+
+if (fs.existsSync(appFile)) {
+  console.log('✅ app.js found');
+  
+  // Change to project directory
+  process.chdir(projectRoot);
+  console.log('Changed to directory:', process.cwd());
+  
+  // Try to require and run the app
+  try {
+    console.log('🚀 Starting OpenCap backend server...');
+    require('./app.js');
+  } catch (error) {
+    console.error('❌ Error starting app:', error.message);
+  }
+} else {
+  console.log('❌ app.js not found');
+}
\ No newline at end of file
diff --git a/tests/setup/app.js b/tests/setup/app.js
new file mode 100644
index 0000000..d079af7
--- /dev/null
+++ b/tests/setup/app.js
@@ -0,0 +1,125 @@
+/**
+ * Test Application Setup
+ * 
+ * Provides Express app instance for testing
+ * Sets up test-specific middleware and configuration
+ */
+
+const express = require('express');
+const cors = require('cors');
+const helmet = require('helmet');
+const compression = require('compression');
+const morgan = require('morgan');
+
+// Import routes
+const authRoutes = require('../../routes/v1/authRoutes');
+const userRoutes = require('../../routes/v1/userRoutes');
+const financialReportRoutes = require('../../routes/v1/financialReportingRoutes');
+const financialMetricsRoutes = require('../../routes/v1/financialMetricsRoutes');
+const companyRoutes = require('../../routes/v1/companyRoutes');
+const stakeholderRoutes = require('../../routes/v1/stakeholderRoutes');
+const documentRoutes = require('../../routes/v1/documentRoutes');
+const adminRoutes = require('../../routes/v1/adminRoutes');
+
+let server;
+
+/**
+ * Create Express app for testing
+ */
+function createApp() {
+  const app = express();
+  
+  // Test environment middleware
+  if (process.env.NODE_ENV === 'test') {
+    app.use(morgan('combined'));
+  }
+  
+  // Security middleware
+  app.use(helmet({
+    crossOriginEmbedderPolicy: false,
+    contentSecurityPolicy: false
+  }));
+  
+  // CORS
+  app.use(cors({
+    origin: true,
+    credentials: true
+  }));
+  
+  // Body parsing
+  app.use(express.json({ limit: '10mb' }));
+  app.use(express.urlencoded({ extended: true }));
+  
+  // Compression
+  app.use(compression());
+  
+  // Health check for tests
+  app.get('/health', (req, res) => {
+    res.json({ status: 'ok', message: 'Test server is running' });
+  });
+  
+  // API routes
+  app.use('/api/v1/auth', authRoutes);
+  app.use('/api/v1/users', userRoutes);
+  app.use('/api/v1/financial-reports', financialReportRoutes);
+  app.use('/api/v1/metrics', financialMetricsRoutes);
+  app.use('/api/v1/companies', companyRoutes);
+  app.use('/api/v1/stakeholders', stakeholderRoutes);
+  app.use('/api/v1/documents', documentRoutes);
+  app.use('/api/v1/admin', adminRoutes);
+  
+  // Legacy routes (for backward compatibility in tests)
+  app.use('/api/users', userRoutes);
+  
+  // Error handling middleware
+  app.use((err, req, res, next) => {
+    console.error('Test app error:', err);
+    res.status(500).json({
+      error: 'Internal server error',
+      message: process.env.NODE_ENV === 'test' ? err.message : 'Something went wrong'
+    });
+  });
+  
+  return app;
+}
+
+/**
+ * Start test server
+ */
+async function startServer(port = 5001) {
+  try {
+    const app = createApp();
+    
+    server = app.listen(port, () => {
+      console.log(`Test server running on port ${port}`);
+    });
+    
+    return server;
+  } catch (error) {
+    console.error('Error starting test server:', error);
+    throw error;
+  }
+}
+
+/**
+ * Stop test server
+ */
+async function stopServer() {
+  try {
+    if (server) {
+      await new Promise((resolve) => {
+        server.close(resolve);
+      });
+      console.log('Test server stopped');
+    }
+  } catch (error) {
+    console.error('Error stopping test server:', error);
+    throw error;
+  }
+}
+
+module.exports = {
+  createApp,
+  startServer,
+  stopServer
+};
\ No newline at end of file
diff --git a/tests/setup/db.js b/tests/setup/db.js
new file mode 100644
index 0000000..9bc17e4
--- /dev/null
+++ b/tests/setup/db.js
@@ -0,0 +1,103 @@
+/**
+ * Test Database Setup and Utilities
+ * 
+ * Provides database connection management for testing
+ * Uses MongoDB Memory Server for isolated testing
+ */
+
+const mongoose = require('mongoose');
+const { MongoMemoryServer } = require('mongodb-memory-server');
+
+let mongoServer;
+
+/**
+ * Connect to the in-memory database
+ */
+async function connectDB() {
+  try {
+    // Start in-memory MongoDB instance
+    mongoServer = await MongoMemoryServer.create({
+      instance: {
+        port: 27018, // Use different port for tests
+        dbName: 'opencap_test'
+      }
+    });
+    
+    const mongoUri = mongoServer.getUri();
+    
+    // Connect to the in-memory database
+    await mongoose.connect(mongoUri, {
+      useNewUrlParser: true,
+      useUnifiedTopology: true,
+    });
+    
+    console.log('Test database connected successfully');
+    return mongoose.connection;
+  } catch (error) {
+    console.error('Error connecting to test database:', error);
+    throw error;
+  }
+}
+
+/**
+ * Close database connection and stop in-memory server
+ */
+async function closeDB() {
+  try {
+    if (mongoose.connection.readyState !== 0) {
+      await mongoose.connection.dropDatabase();
+      await mongoose.connection.close();
+    }
+    
+    if (mongoServer) {
+      await mongoServer.stop();
+    }
+    
+    console.log('Test database disconnected successfully');
+  } catch (error) {
+    console.error('Error closing test database:', error);
+    throw error;
+  }
+}
+
+/**
+ * Clear all collections in the database
+ */
+async function clearDB() {
+  try {
+    const collections = mongoose.connection.collections;
+    
+    for (const key in collections) {
+      const collection = collections[key];
+      await collection.deleteMany({});
+    }
+    
+    console.log('Test database cleared');
+  } catch (error) {
+    console.error('Error clearing test database:', error);
+    throw error;
+  }
+}
+
+/**
+ * Create test data for a given model
+ */
+async function createTestData(Model, data) {
+  try {
+    if (Array.isArray(data)) {
+      return await Model.insertMany(data);
+    } else {
+      return await Model.create(data);
+    }
+  } catch (error) {
+    console.error('Error creating test data:', error);
+    throw error;
+  }
+}
+
+module.exports = {
+  connectDB,
+  closeDB,
+  clearDB,
+  createTestData
+};
\ No newline at end of file
diff --git a/tests/utils/testHelpers.js b/tests/utils/testHelpers.js
new file mode 100644
index 0000000..3fe354c
--- /dev/null
+++ b/tests/utils/testHelpers.js
@@ -0,0 +1,185 @@
+/**
+ * Test Helper Utilities
+ * 
+ * Common utilities and fixtures for testing
+ */
+
+const jwt = require('jsonwebtoken');
+const bcrypt = require('bcrypt');
+const mongoose = require('mongoose');
+const User = require('../../models/User');
+const Company = require('../../models/Company');
+const FinancialReport = require('../../models/financialReport');
+
+/**
+ * Generate JWT token for testing
+ */
+function generateTestToken(userId = 'test-user-id', role = 'user') {
+  const secret = process.env.JWT_SECRET || 'test-secret-key';
+  return jwt.sign(
+    { 
+      id: userId, 
+      role,
+      email: 'test@example.com'
+    },
+    secret,
+    { expiresIn: '1h' }
+  );
+}
+
+/**
+ * Create test user
+ */
+async function createTestUser(userData = {}) {
+  const defaultUser = {
+    userId: `user-${Date.now()}-${Math.random().toString(36).substring(7)}`,
+    firstName: 'Test',
+    lastName: 'User',
+    email: `test-${Date.now()}-${Math.random().toString(36).substring(7)}@example.com`,
+    password: await bcrypt.hash('password123', 10),
+    role: 'user',
+    status: 'active',
+    companyId: new mongoose.Types.ObjectId(),
+    emailVerified: true,
+    profile: {
+      bio: 'Test user bio',
+      address: {
+        city: 'Test City',
+        state: 'Test State',
+        country: 'Test Country'
+      }
+    }
+  };
+  
+  const user = new User({ ...defaultUser, ...userData });
+  return await user.save();
+}
+
+/**
+ * Create test admin user
+ */
+async function createTestAdmin(userData = {}) {
+  return await createTestUser({
+    role: 'admin',
+    email: `admin-${Date.now()}@example.com`,
+    ...userData
+  });
+}
+
+/**
+ * Create test company
+ */
+async function createTestCompany(companyData = {}) {
+  const defaultCompany = {
+    companyId: `company-${Date.now()}`,
+    CompanyName: `Test Company ${Date.now()}`,
+    CompanyType: 'startup',
+    RegisteredAddress: '123 Test Street, Test City, TS 12345',
+    TaxID: `${Math.random().toString().substr(2, 9)}`,
+    corporationDate: new Date('2020-01-01')
+  };
+  
+  const company = new Company({ ...defaultCompany, ...companyData });
+  return await company.save();
+}
+
+/**
+ * Create test financial report
+ */
+async function createTestFinancialReport(reportData = {}) {
+  const company = reportData.companyId || await createTestCompany();
+  
+  const defaultReport = {
+    companyId: company._id || company,
+    reportingPeriod: 'Q1 2024',
+    reportType: 'quarterly',
+    reportDate: new Date(),
+    revenue: {
+      sales: 100000,
+      services: 50000,
+      other: 10000
+    },
+    expenses: {
+      salaries: 80000,
+      marketing: 20000,
+      operations: 15000,
+      other: 5000
+    },
+    totalRevenue: 160000,
+    totalExpenses: 120000,
+    netIncome: 40000,
+    notes: 'Test financial report'
+  };
+  
+  const report = new FinancialReport({ ...defaultReport, ...reportData });
+  return await report.save();
+}
+
+/**
+ * Authentication helper for API tests
+ */
+function createAuthHeaders(token) {
+  return {
+    'Authorization': `Bearer ${token}`,
+    'Content-Type': 'application/json'
+  };
+}
+
+/**
+ * Wait for async operations
+ */
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Generate random test data
+ */
+const testData = {
+  email: () => `test-${Date.now()}-${Math.random().toString(36).substring(7)}@example.com`,
+  name: () => `Test User ${Date.now()}`,
+  company: () => `Test Company ${Date.now()}`,
+  id: () => `test-${Date.now()}-${Math.random().toString(36).substring(7)}`
+};
+
+/**
+ * Validate response format
+ */
+function validateApiResponse(response, expectedFields = []) {
+  expect(response).toHaveProperty('status');
+  expect(response).toHaveProperty('body');
+  
+  if (expectedFields.length > 0) {
+    expectedFields.forEach(field => {
+      expect(response.body).toHaveProperty(field);
+    });
+  }
+}
+
+/**
+ * Test database constraints
+ */
+async function testDatabaseConstraints(Model, invalidData, expectedError) {
+  try {
+    await Model.create(invalidData);
+    throw new Error('Expected validation error but none was thrown');
+  } catch (error) {
+    expect(error.name).toBe('ValidationError');
+    if (expectedError) {
+      expect(error.message).toContain(expectedError);
+    }
+  }
+}
+
+module.exports = {
+  generateTestToken,
+  createTestUser,
+  createTestAdmin,
+  createTestCompany,
+  createTestFinancialReport,
+  createAuthHeaders,
+  sleep,
+  testData,
+  validateApiResponse,
+  testDatabaseConstraints
+};
\ No newline at end of file
diff --git a/utils/auth.js b/utils/auth.js
index de578bd..d495305 100644
--- a/utils/auth.js
+++ b/utils/auth.js
@@ -1,6 +1,11 @@
 const jwt = require('jsonwebtoken');
 
-const JWT_SECRET = process.env.JWT_SECRET || 'test-secret';
+const JWT_SECRET = process.env.JWT_SECRET;
+
+if (!JWT_SECRET) {
+  console.error('FATAL: JWT_SECRET environment variable is required');
+  process.exit(1);
+}
 
 const generateToken = (payload, options = { expiresIn: '1h' }) => {
   return jwt.sign(payload, JWT_SECRET, options);
@@ -14,8 +19,12 @@ const validateApiKey = (req, res, next) => {
     return res.status(401).json({ error: 'Authentication required' });
   }
 
-  if (apiKey && apiKey !== 'valid-key') {
-    return res.status(401).json({ error: 'Invalid API key' });
+  if (apiKey) {
+    // Validate API key against environment variable or database
+    const validApiKey = process.env.API_KEY;
+    if (!validApiKey || apiKey !== validApiKey) {
+      return res.status(401).json({ error: 'Invalid API key' });
+    }
   }
 
   if (authHeader) {
diff --git a/utils/mongoDbConnection.js b/utils/mongoDbConnection.js
index 08ceaeb..f93c868 100644
--- a/utils/mongoDbConnection.js
+++ b/utils/mongoDbConnection.js
@@ -37,7 +37,11 @@ const DEFAULT_MONGOOSE_OPTIONS = {
  */
 function getMongoURI(dbName = null) {
   // Default to environment variable
-  const uri = process.env.MONGO_URI || 'mongodb://opencap:password123@127.0.0.1:27017/opencap_test?authSource=admin';
+  const uri = process.env.MONGO_URI;
+  
+  if (!uri) {
+    throw new Error('MONGO_URI environment variable is required');
+  }
   
   // If dbName is specified, replace the database name in the URI
   if (dbName) {