first

.dockerignore

@@ -0,0 +1,33 @@
+# Dependencies
+node_modules/
+npm-debug.log*
+
+# Environment files
+.env
+.env.local
+.env.*.local
+
+# Vector database (will be created in container)
+chroma_db/
+
+# Git
+.git/
+.gitignore
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Documentation
+README.md
+
+# Build artifacts
+dist/
+build/
+

.gitignore

@@ -0,0 +1,30 @@
+# Dependencies
+node_modules/
+
+# Environment variables
+.env
+.env.local
+.env.*.local
+
+# Vector database
+chroma_db/
+
+# Logs
+logs/
+*.log
+npm-debug.log*
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Build
+dist/
+build/
+

Dockerfile

@@ -0,0 +1,32 @@
+# Use Node.js LTS version
+FROM node:20-alpine
+
+# Set working directory
+WORKDIR /app
+
+# Copy package files
+COPY package*.json ./
+
+# Install dependencies
+RUN npm install --production
+
+# Copy source code
+COPY . .
+
+# Create directory for ChromaDB data
+RUN mkdir -p /app/chroma_db
+
+# Expose port
+EXPOSE 7860
+
+# Set environment variables
+ENV NODE_ENV=production
+ENV PORT=7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+  CMD node -e "require('http').get('http://localhost:7860/', (r) => process.exit(r.statusCode === 200 ? 0 : 1))"
+
+# Start the server
+CMD ["node", "app.js"]
+

app.js

@@ -0,0 +1,62 @@
+import express from 'express';
+import cors from 'cors';
+import dotenv from 'dotenv';
+import { connectDB, ensureIndexes } from './db/mongo.js';
+import authRoutes from './routes/auth.js';
+import patientRoutes from './routes/patients.js';
+import appointmentRoutes from './routes/appointments.js';
+import warningRoutes from './routes/warnings.js';
+
+dotenv.config();
+
+const app = express();
+const PORT = process.env.PORT || 7860;
+
+// Middleware
+app.use(express.json());
+app.use(cors({
+  origin: [
+    'http://localhost:3000',
+    'http://localhost:5173',
+    'http://127.0.0.1:3000',
+    'http://127.0.0.1:5173'
+  ],
+  credentials: true,
+  methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
+  allowedHeaders: ['Content-Type', 'Authorization']
+}));
+
+// Routes
+app.use('/api/auth', authRoutes);
+app.use('/api', patientRoutes);
+app.use('/api', appointmentRoutes);
+app.use('/api', warningRoutes);
+
+// Root endpoint
+app.get('/', (req, res) => {
+  res.json({ message: 'Welcome to the Personalized Patient Information System!' });
+});
+
+// Error handling middleware
+app.use((err, req, res, next) => {
+  console.error(err.stack);
+  res.status(500).json({ detail: err.message || 'Internal Server Error' });
+});
+
+// Start server
+const startServer = async () => {
+  try {
+    await connectDB();
+    await ensureIndexes();
+    
+    app.listen(PORT, () => {
+      console.log(`✓ Server running on port ${PORT}`);
+    });
+  } catch (error) {
+    console.error('Failed to start server:', error);
+    process.exit(1);
+  }
+};
+
+startServer();
+

bun.lock

@@ -0,0 +1,299 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "patients-backend-express",
+      "dependencies": {
+        "@google/generative-ai": "^0.21.0",
+        "bcryptjs": "^2.4.3",
+        "chromadb": "^1.9.2",
+        "cors": "^2.8.5",
+        "dotenv": "^16.3.1",
+        "express": "^4.18.2",
+        "jsonwebtoken": "^9.0.2",
+        "mongodb": "^6.3.0",
+        "openai": "^4.24.0",
+      },
+    },
+  },
+  "packages": {
+    "@google/generative-ai": ["@google/generative-ai@0.21.0", "", {}, "sha512-7XhUbtnlkSEZK15kN3t+tzIMxsbKm/dSkKBFalj+20NvPKe1kBY7mR2P7vuijEn+f06z5+A8bVGKO0v39cr6Wg=="],
+
+    "@mongodb-js/saslprep": ["@mongodb-js/saslprep@1.4.0", "", { "dependencies": { "sparse-bitfield": "^3.0.3" } }, "sha512-ZHzx7Z3rdlWL1mECydvpryWN/ETXJiCxdgQKTAH+djzIPe77HdnSizKBDi1TVDXZjXyOj2IqEG/vPw71ULF06w=="],
+
+    "@types/node": ["@types/node@18.19.130", "", { "dependencies": { "undici-types": "~5.26.4" } }, "sha512-GRaXQx6jGfL8sKfaIDD6OupbIHBr9jv7Jnaml9tB7l4v068PAOXqfcujMMo5PhbIs6ggR1XODELqahT2R8v0fg=="],
+
+    "@types/node-fetch": ["@types/node-fetch@2.6.13", "", { "dependencies": { "@types/node": "*", "form-data": "^4.0.4" } }, "sha512-QGpRVpzSaUs30JBSGPjOg4Uveu384erbHBoT1zeONvyCfwQxIkUshLAOqN/k9EjGviPRmWTTe6aH2qySWKTVSw=="],
+
+    "@types/webidl-conversions": ["@types/webidl-conversions@7.0.3", "", {}, "sha512-CiJJvcRtIgzadHCYXw7dqEnMNRjhGZlYK05Mj9OyktqV8uVT8fD2BFOB7S1uwBE3Kj2Z+4UyPmFw/Ixgw/LAlA=="],
+
+    "@types/whatwg-url": ["@types/whatwg-url@11.0.5", "", { "dependencies": { "@types/webidl-conversions": "*" } }, "sha512-coYR071JRaHa+xoEvvYqvnIHaVqaYrLPbsufM9BF63HkwI5Lgmy2QR8Q5K/lYDYo5AK82wOvSOS0UsLTpTG7uQ=="],
+
+    "abort-controller": ["abort-controller@3.0.0", "", { "dependencies": { "event-target-shim": "^5.0.0" } }, "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg=="],
+
+    "accepts": ["accepts@1.3.8", "", { "dependencies": { "mime-types": "~2.1.34", "negotiator": "0.6.3" } }, "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw=="],
+
+    "agentkeepalive": ["agentkeepalive@4.6.0", "", { "dependencies": { "humanize-ms": "^1.2.1" } }, "sha512-kja8j7PjmncONqaTsB8fQ+wE2mSU2DJ9D4XKoJ5PFWIdRMa6SLSN1ff4mOr4jCbfRSsxR4keIiySJU0N9T5hIQ=="],
+
+    "ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
+
+    "ansi-styles": ["ansi-styles@4.3.0", "", { "dependencies": { "color-convert": "^2.0.1" } }, "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="],
+
+    "array-flatten": ["array-flatten@1.1.1", "", {}, "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg=="],
+
+    "asynckit": ["asynckit@0.4.0", "", {}, "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="],
+
+    "bcryptjs": ["bcryptjs@2.4.3", "", {}, "sha512-V/Hy/X9Vt7f3BbPJEi8BdVFMByHi+jNXrYkW3huaybV/kQ0KJg0Y6PkEMbn+zeT+i+SiKZ/HMqJGIIt4LZDqNQ=="],
+
+    "body-parser": ["body-parser@1.20.4", "", { "dependencies": { "bytes": "~3.1.2", "content-type": "~1.0.5", "debug": "2.6.9", "depd": "2.0.0", "destroy": "~1.2.0", "http-errors": "~2.0.1", "iconv-lite": "~0.4.24", "on-finished": "~2.4.1", "qs": "~6.14.0", "raw-body": "~2.5.3", "type-is": "~1.6.18", "unpipe": "~1.0.0" } }, "sha512-ZTgYYLMOXY9qKU/57FAo8F+HA2dGX7bqGc71txDRC1rS4frdFI5R7NhluHxH6M0YItAP0sHB4uqAOcYKxO6uGA=="],
+
+    "bson": ["bson@6.10.4", "", {}, "sha512-WIsKqkSC0ABoBJuT1LEX+2HEvNmNKKgnTAyd0fL8qzK4SH2i9NXg+t08YtdZp/V9IZ33cxe3iV4yM0qg8lMQng=="],
+
+    "buffer-equal-constant-time": ["buffer-equal-constant-time@1.0.1", "", {}, "sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA=="],
+
+    "bytes": ["bytes@3.1.2", "", {}, "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg=="],
+
+    "call-bind-apply-helpers": ["call-bind-apply-helpers@1.0.2", "", { "dependencies": { "es-errors": "^1.3.0", "function-bind": "^1.1.2" } }, "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ=="],
+
+    "call-bound": ["call-bound@1.0.4", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "get-intrinsic": "^1.3.0" } }, "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg=="],
+
+    "chromadb": ["chromadb@1.10.5", "", { "dependencies": { "cliui": "^8.0.1", "isomorphic-fetch": "^3.0.0" }, "peerDependencies": { "@google/generative-ai": "^0.1.1", "cohere-ai": "^5.0.0 || ^6.0.0 || ^7.0.0", "ollama": "^0.5.0", "openai": "^3.0.0 || ^4.0.0", "voyageai": "^0.0.3-1" }, "optionalPeers": ["@google/generative-ai", "cohere-ai", "ollama", "openai", "voyageai"] }, "sha512-+IeTjjf44pKUY3vp1BacwO2tFAPcWCd64zxPZZm98dVj/kbSBeaHKB2D6eX7iRLHS1PTVASuqoR6mAJ+nrsTBg=="],
+
+    "cliui": ["cliui@8.0.1", "", { "dependencies": { "string-width": "^4.2.0", "strip-ansi": "^6.0.1", "wrap-ansi": "^7.0.0" } }, "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ=="],
+
+    "color-convert": ["color-convert@2.0.1", "", { "dependencies": { "color-name": "~1.1.4" } }, "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ=="],
+
+    "color-name": ["color-name@1.1.4", "", {}, "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="],
+
+    "combined-stream": ["combined-stream@1.0.8", "", { "dependencies": { "delayed-stream": "~1.0.0" } }, "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg=="],
+
+    "content-disposition": ["content-disposition@0.5.4", "", { "dependencies": { "safe-buffer": "5.2.1" } }, "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ=="],
+
+    "content-type": ["content-type@1.0.5", "", {}, "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA=="],
+
+    "cookie": ["cookie@0.7.2", "", {}, "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w=="],
+
+    "cookie-signature": ["cookie-signature@1.0.7", "", {}, "sha512-NXdYc3dLr47pBkpUCHtKSwIOQXLVn8dZEuywboCOJY/osA0wFSLlSawr3KN8qXJEyX66FcONTH8EIlVuK0yyFA=="],
+
+    "cors": ["cors@2.8.5", "", { "dependencies": { "object-assign": "^4", "vary": "^1" } }, "sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g=="],
+
+    "debug": ["debug@2.6.9", "", { "dependencies": { "ms": "2.0.0" } }, "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA=="],
+
+    "delayed-stream": ["delayed-stream@1.0.0", "", {}, "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ=="],
+
+    "depd": ["depd@2.0.0", "", {}, "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw=="],
+
+    "destroy": ["destroy@1.2.0", "", {}, "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg=="],
+
+    "dotenv": ["dotenv@16.6.1", "", {}, "sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow=="],
+
+    "dunder-proto": ["dunder-proto@1.0.1", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.1", "es-errors": "^1.3.0", "gopd": "^1.2.0" } }, "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A=="],
+
+    "ecdsa-sig-formatter": ["ecdsa-sig-formatter@1.0.11", "", { "dependencies": { "safe-buffer": "^5.0.1" } }, "sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ=="],
+
+    "ee-first": ["ee-first@1.1.1", "", {}, "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow=="],
+
+    "emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="],
+
+    "encodeurl": ["encodeurl@2.0.0", "", {}, "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg=="],
+
+    "es-define-property": ["es-define-property@1.0.1", "", {}, "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g=="],
+
+    "es-errors": ["es-errors@1.3.0", "", {}, "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw=="],
+
+    "es-object-atoms": ["es-object-atoms@1.1.1", "", { "dependencies": { "es-errors": "^1.3.0" } }, "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA=="],
+
+    "es-set-tostringtag": ["es-set-tostringtag@2.1.0", "", { "dependencies": { "es-errors": "^1.3.0", "get-intrinsic": "^1.2.6", "has-tostringtag": "^1.0.2", "hasown": "^2.0.2" } }, "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA=="],
+
+    "escape-html": ["escape-html@1.0.3", "", {}, "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow=="],
+
+    "etag": ["etag@1.8.1", "", {}, "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg=="],
+
+    "event-target-shim": ["event-target-shim@5.0.1", "", {}, "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ=="],
+
+    "express": ["express@4.22.1", "", { "dependencies": { "accepts": "~1.3.8", "array-flatten": "1.1.1", "body-parser": "~1.20.3", "content-disposition": "~0.5.4", "content-type": "~1.0.4", "cookie": "~0.7.1", "cookie-signature": "~1.0.6", "debug": "2.6.9", "depd": "2.0.0", "encodeurl": "~2.0.0", "escape-html": "~1.0.3", "etag": "~1.8.1", "finalhandler": "~1.3.1", "fresh": "~0.5.2", "http-errors": "~2.0.0", "merge-descriptors": "1.0.3", "methods": "~1.1.2", "on-finished": "~2.4.1", "parseurl": "~1.3.3", "path-to-regexp": "~0.1.12", "proxy-addr": "~2.0.7", "qs": "~6.14.0", "range-parser": "~1.2.1", "safe-buffer": "5.2.1", "send": "~0.19.0", "serve-static": "~1.16.2", "setprototypeof": "1.2.0", "statuses": "~2.0.1", "type-is": "~1.6.18", "utils-merge": "1.0.1", "vary": "~1.1.2" } }, "sha512-F2X8g9P1X7uCPZMA3MVf9wcTqlyNp7IhH5qPCI0izhaOIYXaW9L535tGA3qmjRzpH+bZczqq7hVKxTR4NWnu+g=="],
+
+    "finalhandler": ["finalhandler@1.3.2", "", { "dependencies": { "debug": "2.6.9", "encodeurl": "~2.0.0", "escape-html": "~1.0.3", "on-finished": "~2.4.1", "parseurl": "~1.3.3", "statuses": "~2.0.2", "unpipe": "~1.0.0" } }, "sha512-aA4RyPcd3badbdABGDuTXCMTtOneUCAYH/gxoYRTZlIJdF0YPWuGqiAsIrhNnnqdXGswYk6dGujem4w80UJFhg=="],
+
+    "form-data": ["form-data@4.0.5", "", { "dependencies": { "asynckit": "^0.4.0", "combined-stream": "^1.0.8", "es-set-tostringtag": "^2.1.0", "hasown": "^2.0.2", "mime-types": "^2.1.12" } }, "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w=="],
+
+    "form-data-encoder": ["form-data-encoder@1.7.2", "", {}, "sha512-qfqtYan3rxrnCk1VYaA4H+Ms9xdpPqvLZa6xmMgFvhO32x7/3J/ExcTd6qpxM0vH2GdMI+poehyBZvqfMTto8A=="],
+
+    "formdata-node": ["formdata-node@4.4.1", "", { "dependencies": { "node-domexception": "1.0.0", "web-streams-polyfill": "4.0.0-beta.3" } }, "sha512-0iirZp3uVDjVGt9p49aTaqjk84TrglENEDuqfdlZQ1roC9CWlPk6Avf8EEnZNcAqPonwkG35x4n3ww/1THYAeQ=="],
+
+    "forwarded": ["forwarded@0.2.0", "", {}, "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow=="],
+
+    "fresh": ["fresh@0.5.2", "", {}, "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q=="],
+
+    "function-bind": ["function-bind@1.1.2", "", {}, "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="],
+
+    "get-intrinsic": ["get-intrinsic@1.3.0", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.1.1", "function-bind": "^1.1.2", "get-proto": "^1.0.1", "gopd": "^1.2.0", "has-symbols": "^1.1.0", "hasown": "^2.0.2", "math-intrinsics": "^1.1.0" } }, "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ=="],
+
+    "get-proto": ["get-proto@1.0.1", "", { "dependencies": { "dunder-proto": "^1.0.1", "es-object-atoms": "^1.0.0" } }, "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g=="],
+
+    "gopd": ["gopd@1.2.0", "", {}, "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="],
+
+    "has-symbols": ["has-symbols@1.1.0", "", {}, "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ=="],
+
+    "has-tostringtag": ["has-tostringtag@1.0.2", "", { "dependencies": { "has-symbols": "^1.0.3" } }, "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw=="],
+
+    "hasown": ["hasown@2.0.2", "", { "dependencies": { "function-bind": "^1.1.2" } }, "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ=="],
+
+    "http-errors": ["http-errors@2.0.1", "", { "dependencies": { "depd": "~2.0.0", "inherits": "~2.0.4", "setprototypeof": "~1.2.0", "statuses": "~2.0.2", "toidentifier": "~1.0.1" } }, "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ=="],
+
+    "humanize-ms": ["humanize-ms@1.2.1", "", { "dependencies": { "ms": "^2.0.0" } }, "sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ=="],
+
+    "iconv-lite": ["iconv-lite@0.4.24", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3" } }, "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA=="],
+
+    "inherits": ["inherits@2.0.4", "", {}, "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="],
+
+    "ipaddr.js": ["ipaddr.js@1.9.1", "", {}, "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g=="],
+
+    "is-fullwidth-code-point": ["is-fullwidth-code-point@3.0.0", "", {}, "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg=="],
+
+    "isomorphic-fetch": ["isomorphic-fetch@3.0.0", "", { "dependencies": { "node-fetch": "^2.6.1", "whatwg-fetch": "^3.4.1" } }, "sha512-qvUtwJ3j6qwsF3jLxkZ72qCgjMysPzDfeV240JHiGZsANBYd+EEuu35v7dfrJ9Up0Ak07D7GGSkGhCHTqg/5wA=="],
+
+    "jsonwebtoken": ["jsonwebtoken@9.0.3", "", { "dependencies": { "jws": "^4.0.1", "lodash.includes": "^4.3.0", "lodash.isboolean": "^3.0.3", "lodash.isinteger": "^4.0.4", "lodash.isnumber": "^3.0.3", "lodash.isplainobject": "^4.0.6", "lodash.isstring": "^4.0.1", "lodash.once": "^4.0.0", "ms": "^2.1.1", "semver": "^7.5.4" } }, "sha512-MT/xP0CrubFRNLNKvxJ2BYfy53Zkm++5bX9dtuPbqAeQpTVe0MQTFhao8+Cp//EmJp244xt6Drw/GVEGCUj40g=="],
+
+    "jwa": ["jwa@2.0.1", "", { "dependencies": { "buffer-equal-constant-time": "^1.0.1", "ecdsa-sig-formatter": "1.0.11", "safe-buffer": "^5.0.1" } }, "sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg=="],
+
+    "jws": ["jws@4.0.1", "", { "dependencies": { "jwa": "^2.0.1", "safe-buffer": "^5.0.1" } }, "sha512-EKI/M/yqPncGUUh44xz0PxSidXFr/+r0pA70+gIYhjv+et7yxM+s29Y+VGDkovRofQem0fs7Uvf4+YmAdyRduA=="],
+
+    "lodash.includes": ["lodash.includes@4.3.0", "", {}, "sha512-W3Bx6mdkRTGtlJISOvVD/lbqjTlPPUDTMnlXZFnVwi9NKJ6tiAk6LVdlhZMm17VZisqhKcgzpO5Wz91PCt5b0w=="],
+
+    "lodash.isboolean": ["lodash.isboolean@3.0.3", "", {}, "sha512-Bz5mupy2SVbPHURB98VAcw+aHh4vRV5IPNhILUCsOzRmsTmSQ17jIuqopAentWoehktxGd9e/hbIXq980/1QJg=="],
+
+    "lodash.isinteger": ["lodash.isinteger@4.0.4", "", {}, "sha512-DBwtEWN2caHQ9/imiNeEA5ys1JoRtRfY3d7V9wkqtbycnAmTvRRmbHKDV4a0EYc678/dia0jrte4tjYwVBaZUA=="],
+
+    "lodash.isnumber": ["lodash.isnumber@3.0.3", "", {}, "sha512-QYqzpfwO3/CWf3XP+Z+tkQsfaLL/EnUlXWVkIk5FUPc4sBdTehEqZONuyRt2P67PXAk+NXmTBcc97zw9t1FQrw=="],
+
+    "lodash.isplainobject": ["lodash.isplainobject@4.0.6", "", {}, "sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA=="],
+
+    "lodash.isstring": ["lodash.isstring@4.0.1", "", {}, "sha512-0wJxfxH1wgO3GrbuP+dTTk7op+6L41QCXbGINEmD+ny/G/eCqGzxyCsh7159S+mgDDcoarnBw6PC1PS5+wUGgw=="],
+
+    "lodash.once": ["lodash.once@4.1.1", "", {}, "sha512-Sb487aTOCr9drQVL8pIxOzVhafOjZN9UU54hiN8PU3uAiSV7lx1yYNpbNmex2PK6dSJoNTSJUUswT651yww3Mg=="],
+
+    "math-intrinsics": ["math-intrinsics@1.1.0", "", {}, "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="],
+
+    "media-typer": ["media-typer@0.3.0", "", {}, "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ=="],
+
+    "memory-pager": ["memory-pager@1.5.0", "", {}, "sha512-ZS4Bp4r/Zoeq6+NLJpP+0Zzm0pR8whtGPf1XExKLJBAczGMnSi3It14OiNCStjQjM6NU1okjQGSxgEZN8eBYKg=="],
+
+    "merge-descriptors": ["merge-descriptors@1.0.3", "", {}, "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ=="],
+
+    "methods": ["methods@1.1.2", "", {}, "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w=="],
+
+    "mime": ["mime@1.6.0", "", { "bin": { "mime": "cli.js" } }, "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg=="],
+
+    "mime-db": ["mime-db@1.52.0", "", {}, "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg=="],
+
+    "mime-types": ["mime-types@2.1.35", "", { "dependencies": { "mime-db": "1.52.0" } }, "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw=="],
+
+    "mongodb": ["mongodb@6.21.0", "", { "dependencies": { "@mongodb-js/saslprep": "^1.3.0", "bson": "^6.10.4", "mongodb-connection-string-url": "^3.0.2" }, "peerDependencies": { "@aws-sdk/credential-providers": "^3.188.0", "@mongodb-js/zstd": "^1.1.0 || ^2.0.0", "gcp-metadata": "^5.2.0", "kerberos": "^2.0.1", "mongodb-client-encryption": ">=6.0.0 <7", "snappy": "^7.3.2", "socks": "^2.7.1" }, "optionalPeers": ["@aws-sdk/credential-providers", "@mongodb-js/zstd", "gcp-metadata", "kerberos", "mongodb-client-encryption", "snappy", "socks"] }, "sha512-URyb/VXMjJ4da46OeSXg+puO39XH9DeQpWCslifrRn9JWugy0D+DvvBvkm2WxmHe61O/H19JM66p1z7RHVkZ6A=="],
+
+    "mongodb-connection-string-url": ["mongodb-connection-string-url@3.0.2", "", { "dependencies": { "@types/whatwg-url": "^11.0.2", "whatwg-url": "^14.1.0 || ^13.0.0" } }, "sha512-rMO7CGo/9BFwyZABcKAWL8UJwH/Kc2x0g72uhDWzG48URRax5TCIcJ7Rc3RZqffZzO/Gwff/jyKwCU9TN8gehA=="],
+
+    "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
+
+    "negotiator": ["negotiator@0.6.3", "", {}, "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg=="],
+
+    "node-domexception": ["node-domexception@1.0.0", "", {}, "sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ=="],
+
+    "node-fetch": ["node-fetch@2.7.0", "", { "dependencies": { "whatwg-url": "^5.0.0" }, "peerDependencies": { "encoding": "^0.1.0" }, "optionalPeers": ["encoding"] }, "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A=="],
+
+    "object-assign": ["object-assign@4.1.1", "", {}, "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg=="],
+
+    "object-inspect": ["object-inspect@1.13.4", "", {}, "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew=="],
+
+    "on-finished": ["on-finished@2.4.1", "", { "dependencies": { "ee-first": "1.1.1" } }, "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg=="],
+
+    "openai": ["openai@4.104.0", "", { "dependencies": { "@types/node": "^18.11.18", "@types/node-fetch": "^2.6.4", "abort-controller": "^3.0.0", "agentkeepalive": "^4.2.1", "form-data-encoder": "1.7.2", "formdata-node": "^4.3.2", "node-fetch": "^2.6.7" }, "peerDependencies": { "ws": "^8.18.0", "zod": "^3.23.8" }, "optionalPeers": ["ws", "zod"], "bin": { "openai": "bin/cli" } }, "sha512-p99EFNsA/yX6UhVO93f5kJsDRLAg+CTA2RBqdHK4RtK8u5IJw32Hyb2dTGKbnnFmnuoBv5r7Z2CURI9sGZpSuA=="],
+
+    "parseurl": ["parseurl@1.3.3", "", {}, "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ=="],
+
+    "path-to-regexp": ["path-to-regexp@0.1.12", "", {}, "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ=="],
+
+    "proxy-addr": ["proxy-addr@2.0.7", "", { "dependencies": { "forwarded": "0.2.0", "ipaddr.js": "1.9.1" } }, "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg=="],
+
+    "punycode": ["punycode@2.3.1", "", {}, "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg=="],
+
+    "qs": ["qs@6.14.0", "", { "dependencies": { "side-channel": "^1.1.0" } }, "sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w=="],
+
+    "range-parser": ["range-parser@1.2.1", "", {}, "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg=="],
+
+    "raw-body": ["raw-body@2.5.3", "", { "dependencies": { "bytes": "~3.1.2", "http-errors": "~2.0.1", "iconv-lite": "~0.4.24", "unpipe": "~1.0.0" } }, "sha512-s4VSOf6yN0rvbRZGxs8Om5CWj6seneMwK3oDb4lWDH0UPhWcxwOWw5+qk24bxq87szX1ydrwylIOp2uG1ojUpA=="],
+
+    "safe-buffer": ["safe-buffer@5.2.1", "", {}, "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="],
+
+    "safer-buffer": ["safer-buffer@2.1.2", "", {}, "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="],
+
+    "semver": ["semver@7.7.3", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q=="],
+
+    "send": ["send@0.19.1", "", { "dependencies": { "debug": "2.6.9", "depd": "2.0.0", "destroy": "1.2.0", "encodeurl": "~2.0.0", "escape-html": "~1.0.3", "etag": "~1.8.1", "fresh": "0.5.2", "http-errors": "2.0.0", "mime": "1.6.0", "ms": "2.1.3", "on-finished": "2.4.1", "range-parser": "~1.2.1", "statuses": "2.0.1" } }, "sha512-p4rRk4f23ynFEfcD9LA0xRYngj+IyGiEYyqqOak8kaN0TvNmuxC2dcVeBn62GpCeR2CpWqyHCNScTP91QbAVFg=="],
+
+    "serve-static": ["serve-static@1.16.2", "", { "dependencies": { "encodeurl": "~2.0.0", "escape-html": "~1.0.3", "parseurl": "~1.3.3", "send": "0.19.0" } }, "sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw=="],
+
+    "setprototypeof": ["setprototypeof@1.2.0", "", {}, "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw=="],
+
+    "side-channel": ["side-channel@1.1.0", "", { "dependencies": { "es-errors": "^1.3.0", "object-inspect": "^1.13.3", "side-channel-list": "^1.0.0", "side-channel-map": "^1.0.1", "side-channel-weakmap": "^1.0.2" } }, "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw=="],
+
+    "side-channel-list": ["side-channel-list@1.0.0", "", { "dependencies": { "es-errors": "^1.3.0", "object-inspect": "^1.13.3" } }, "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA=="],
+
+    "side-channel-map": ["side-channel-map@1.0.1", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.5", "object-inspect": "^1.13.3" } }, "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA=="],
+
+    "side-channel-weakmap": ["side-channel-weakmap@1.0.2", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.5", "object-inspect": "^1.13.3", "side-channel-map": "^1.0.1" } }, "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A=="],
+
+    "sparse-bitfield": ["sparse-bitfield@3.0.3", "", { "dependencies": { "memory-pager": "^1.0.2" } }, "sha512-kvzhi7vqKTfkh0PZU+2D2PIllw2ymqJKujUcyPMd9Y75Nv4nPbGJZXNhxsgdQab2BmlDct1YnfQCguEvHr7VsQ=="],
+
+    "statuses": ["statuses@2.0.2", "", {}, "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw=="],
+
+    "string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],
+
+    "strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
+
+    "toidentifier": ["toidentifier@1.0.1", "", {}, "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA=="],
+
+    "tr46": ["tr46@5.1.1", "", { "dependencies": { "punycode": "^2.3.1" } }, "sha512-hdF5ZgjTqgAntKkklYw0R03MG2x/bSzTtkxmIRw/sTNV8YXsCJ1tfLAX23lhxhHJlEf3CRCOCGGWw3vI3GaSPw=="],
+
+    "type-is": ["type-is@1.6.18", "", { "dependencies": { "media-typer": "0.3.0", "mime-types": "~2.1.24" } }, "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g=="],
+
+    "undici-types": ["undici-types@5.26.5", "", {}, "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA=="],
+
+    "unpipe": ["unpipe@1.0.0", "", {}, "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ=="],
+
+    "utils-merge": ["utils-merge@1.0.1", "", {}, "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA=="],
+
+    "vary": ["vary@1.1.2", "", {}, "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg=="],
+
+    "web-streams-polyfill": ["web-streams-polyfill@4.0.0-beta.3", "", {}, "sha512-QW95TCTaHmsYfHDybGMwO5IJIM93I/6vTRk+daHTWFPhwh+C8Cg7j7XyKrwrj8Ib6vYXe0ocYNrmzY4xAAN6ug=="],
+
+    "webidl-conversions": ["webidl-conversions@7.0.0", "", {}, "sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g=="],
+
+    "whatwg-fetch": ["whatwg-fetch@3.6.20", "", {}, "sha512-EqhiFU6daOA8kpjOWTL0olhVOF3i7OrFzSYiGsEMB8GcXS+RrzauAERX65xMeNWVqxA6HXH2m69Z9LaKKdisfg=="],
+
+    "whatwg-url": ["whatwg-url@14.2.0", "", { "dependencies": { "tr46": "^5.1.0", "webidl-conversions": "^7.0.0" } }, "sha512-De72GdQZzNTUBBChsXueQUnPKDkg/5A5zp7pFDuQAj5UFoENpiACU0wlCvzpAGnTkj++ihpKwKyYewn/XNUbKw=="],
+
+    "wrap-ansi": ["wrap-ansi@7.0.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q=="],
+
+    "debug/ms": ["ms@2.0.0", "", {}, "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A=="],
+
+    "node-fetch/whatwg-url": ["whatwg-url@5.0.0", "", { "dependencies": { "tr46": "~0.0.3", "webidl-conversions": "^3.0.0" } }, "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw=="],
+
+    "send/http-errors": ["http-errors@2.0.0", "", { "dependencies": { "depd": "2.0.0", "inherits": "2.0.4", "setprototypeof": "1.2.0", "statuses": "2.0.1", "toidentifier": "1.0.1" } }, "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ=="],
+
+    "send/statuses": ["statuses@2.0.1", "", {}, "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ=="],
+
+    "serve-static/send": ["send@0.19.0", "", { "dependencies": { "debug": "2.6.9", "depd": "2.0.0", "destroy": "1.2.0", "encodeurl": "~1.0.2", "escape-html": "~1.0.3", "etag": "~1.8.1", "fresh": "0.5.2", "http-errors": "2.0.0", "mime": "1.6.0", "ms": "2.1.3", "on-finished": "2.4.1", "range-parser": "~1.2.1", "statuses": "2.0.1" } }, "sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw=="],
+
+    "node-fetch/whatwg-url/tr46": ["tr46@0.0.3", "", {}, "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw=="],
+
+    "node-fetch/whatwg-url/webidl-conversions": ["webidl-conversions@3.0.1", "", {}, "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ=="],
+
+    "serve-static/send/encodeurl": ["encodeurl@1.0.2", "", {}, "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w=="],
+
+    "serve-static/send/http-errors": ["http-errors@2.0.0", "", { "dependencies": { "depd": "2.0.0", "inherits": "2.0.4", "setprototypeof": "1.2.0", "statuses": "2.0.1", "toidentifier": "1.0.1" } }, "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ=="],
+
+    "serve-static/send/statuses": ["statuses@2.0.1", "", {}, "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ=="],
+  }
+}

db/mongo.js

@@ -0,0 +1,73 @@
+import { MongoClient, ObjectId } from 'mongodb';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const MONGO_URI = process.env.MONGO_URI;
+
+let client;
+let db;
+
+// Collections
+let patientsCollection;
+let usersCollection;
+let appointmentsCollection;
+let warningsCollection;
+
+export const connectDB = async () => {
+  try {
+    client = new MongoClient(MONGO_URI, {
+      serverSelectionTimeoutMS: 5000
+    });
+    
+    await client.connect();
+    await client.db('admin').command({ ping: 1 });
+    console.log('✓ Connected to MongoDB Atlas successfully!');
+    
+    db = client.db('patient_info');
+    
+    // Initialize collections
+    patientsCollection = db.collection('patients');
+    usersCollection = db.collection('users');
+    appointmentsCollection = db.collection('appointments');
+    warningsCollection = db.collection('clinical_warnings');
+    
+    return db;
+  } catch (error) {
+    console.log(`⚠️ MongoDB connection warning: ${error.message}`);
+    console.log('The server will start, but database operations may fail.');
+    console.log('Please check:');
+    console.log('  1. Your MongoDB Atlas IP whitelist (add your current IP)');
+    console.log('  2. Your internet connection');
+    console.log('  3. If your Atlas cluster is paused');
+    
+    // Create client anyway for later retry
+    client = new MongoClient(MONGO_URI);
+    db = client.db('patient_info');
+    
+    patientsCollection = db.collection('patients');
+    usersCollection = db.collection('users');
+    appointmentsCollection = db.collection('appointments');
+    warningsCollection = db.collection('clinical_warnings');
+    
+    return db;
+  }
+};
+
+export const ensureIndexes = async () => {
+  try {
+    await usersCollection.createIndex({ email: 1 }, { unique: true });
+    console.log('✓ Database indexes created');
+  } catch (error) {
+    console.log(`⚠️ Could not create indexes: ${error.message}`);
+  }
+};
+
+export const getDB = () => db;
+export const getPatientsCollection = () => patientsCollection;
+export const getUsersCollection = () => usersCollection;
+export const getAppointmentsCollection = () => appointmentsCollection;
+export const getWarningsCollection = () => warningsCollection;
+
+export { ObjectId };
+

docker-compose.yml

@@ -0,0 +1,28 @@
+version: '3.8'
+
+services:
+  backend:
+    build: .
+    container_name: patients-express-backend
+    ports:
+      - "8000:8000"
+    environment:
+      - NODE_ENV=production
+      - PORT=8000
+      - MONGO_URI=${MONGO_URI}
+      - JWT_SECRET_KEY=${JWT_SECRET_KEY}
+      - HF_TOKEN=${HF_TOKEN}
+    volumes:
+      - chroma_data:/app/chroma_db
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "node", "-e", "require('http').get('http://localhost:8000/', (r) => process.exit(r.statusCode === 200 ? 0 : 1))"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 10s
+
+volumes:
+  chroma_data:
+    driver: local
+

middleware/auth.js

@@ -0,0 +1,121 @@
+import { authService } from '../services/authService.js';
+
+// User roles enum
+export const UserRole = {
+  DOCTOR: 'doctor',
+  PATIENT: 'patient'
+};
+
+/**
+ * Middleware to get the current authenticated user from JWT token
+ */
+export const getCurrentUser = async (req, res, next) => {
+  try {
+    const authHeader = req.headers.authorization;
+    
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+      return res.status(401).json({
+        detail: 'Could not validate credentials',
+        headers: { 'WWW-Authenticate': 'Bearer' }
+      });
+    }
+    
+    const token = authHeader.split(' ')[1];
+    const tokenData = authService.decodeToken(token);
+    
+    if (!tokenData) {
+      return res.status(401).json({
+        detail: 'Could not validate credentials',
+        headers: { 'WWW-Authenticate': 'Bearer' }
+      });
+    }
+    
+    const user = await authService.getUserById(tokenData.userId);
+    
+    if (!user) {
+      return res.status(401).json({
+        detail: 'Could not validate credentials',
+        headers: { 'WWW-Authenticate': 'Bearer' }
+      });
+    }
+    
+    if (!user.is_active) {
+      return res.status(403).json({
+        detail: 'User account is disabled'
+      });
+    }
+    
+    req.user = user;
+    next();
+  } catch (error) {
+    return res.status(401).json({
+      detail: 'Could not validate credentials'
+    });
+  }
+};
+
+/**
+ * Middleware to ensure the current user is active
+ */
+export const getCurrentActiveUser = async (req, res, next) => {
+  await getCurrentUser(req, res, () => {
+    if (!req.user.is_active) {
+      return res.status(403).json({
+        detail: 'Inactive user'
+      });
+    }
+    next();
+  });
+};
+
+/**
+ * Factory function to require specific roles
+ */
+export const requireRoles = (allowedRoles) => {
+  return async (req, res, next) => {
+    await getCurrentUser(req, res, () => {
+      const userRole = req.user.role || 'patient';
+      
+      if (!allowedRoles.includes(userRole)) {
+        return res.status(403).json({
+          detail: `Access denied. Required roles: ${allowedRoles.join(', ')}`
+        });
+      }
+      next();
+    });
+  };
+};
+
+// Pre-built role middlewares for common use cases
+export const requireDoctor = requireRoles([UserRole.DOCTOR]);
+export const requireStaff = requireRoles([UserRole.DOCTOR]);
+
+/**
+ * Optional authentication - doesn't fail if no token provided
+ */
+export const optionalAuth = async (req, res, next) => {
+  try {
+    const authHeader = req.headers.authorization;
+    
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+      req.user = null;
+      return next();
+    }
+    
+    const token = authHeader.split(' ')[1];
+    const tokenData = authService.decodeToken(token);
+    
+    if (!tokenData) {
+      req.user = null;
+      return next();
+    }
+    
+    const user = await authService.getUserById(tokenData.userId);
+    req.user = user || null;
+    next();
+  } catch (error) {
+    req.user = null;
+    next();
+  }
+};
+

package.json

@@ -0,0 +1,31 @@
+{
+  "name": "patients-backend-express",
+  "version": "1.0.0",
+  "description": "Personalized Patient Information System - Express.js Backend",
+  "main": "app.js",
+  "type": "module",
+  "scripts": {
+    "start": "node app.js",
+    "dev": "node --watch app.js"
+  },
+  "keywords": [
+    "healthcare",
+    "patient",
+    "medical",
+    "express",
+    "mongodb"
+  ],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "express": "^4.18.2",
+    "cors": "^2.8.5",
+    "dotenv": "^16.3.1",
+    "mongodb": "^6.3.0",
+    "jsonwebtoken": "^9.0.2",
+    "bcryptjs": "^2.4.3",
+    "openai": "^4.24.0",
+    "chromadb": "^1.9.2"
+  }
+}
+

routes/appointments.js

@@ -0,0 +1,282 @@
+import express from 'express';
+import { ObjectId } from '../db/mongo.js';
+import { appointmentService } from '../services/appointmentService.js';
+import { getCurrentUser, requireStaff } from '../middleware/auth.js';
+
+const router = express.Router();
+
+/**
+ * Validate ObjectId format
+ */
+const isValidObjectId = (id) => {
+  try {
+    return ObjectId.isValid(id) && new ObjectId(id).toString() === id;
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * POST /api/appointments
+ * Create a new appointment
+ */
+router.post('/appointments', requireStaff, async (req, res) => {
+  try {
+    const userId = req.user._id.toString();
+    const appointmentData = req.body;
+    
+    // If no doctor_id specified, use current user as doctor
+    if (!appointmentData.doctor_id) {
+      appointmentData.doctor_id = userId;
+    }
+    
+    // Check for conflicts if doctor is assigned
+    if (appointmentData.doctor_id) {
+      const conflicts = await appointmentService.checkConflicts(
+        appointmentData.doctor_id,
+        appointmentData.date_time,
+        appointmentData.duration_minutes || 30
+      );
+      
+      if (conflicts.length > 0) {
+        return res.status(409).json({
+          detail: {
+            message: 'Scheduling conflict detected',
+            conflicts
+          }
+        });
+      }
+    }
+    
+    const appointment = await appointmentService.createAppointment(appointmentData, userId);
+    res.status(201).json(appointment);
+  } catch (error) {
+    res.status(500).json({ detail: `Error creating appointment: ${error.message}` });
+  }
+});
+
+/**
+ * GET /api/appointments
+ * List appointments with optional filters
+ */
+router.get('/appointments', getCurrentUser, async (req, res) => {
+  try {
+    const { patient_id, doctor_id, status, from_date, to_date, limit = 50 } = req.query;
+    
+    const appointments = await appointmentService.listAppointments({
+      patientId: patient_id,
+      doctorId: doctor_id,
+      status,
+      fromDate: from_date,
+      toDate: to_date,
+      limit: Math.min(parseInt(limit), 100)
+    });
+    
+    res.json(appointments);
+  } catch (error) {
+    res.status(500).json({ detail: `Error fetching appointments: ${error.message}` });
+  }
+});
+
+/**
+ * GET /api/appointments/upcoming
+ * Get upcoming appointments
+ */
+router.get('/appointments/upcoming', getCurrentUser, async (req, res) => {
+  try {
+    const { limit = 20 } = req.query;
+    const appointments = await appointmentService.getUpcomingAppointments(
+      Math.min(parseInt(limit), 100)
+    );
+    res.json(appointments);
+  } catch (error) {
+    res.status(500).json({ detail: `Error fetching appointments: ${error.message}` });
+  }
+});
+
+/**
+ * GET /api/appointments/stats
+ * Get appointment statistics
+ */
+router.get('/appointments/stats', getCurrentUser, async (req, res) => {
+  try {
+    const stats = await appointmentService.getAppointmentStats();
+    res.json(stats);
+  } catch (error) {
+    res.status(500).json({ detail: `Error fetching stats: ${error.message}` });
+  }
+});
+
+/**
+ * GET /api/appointments/:appointmentId
+ * Get a specific appointment
+ */
+router.get('/appointments/:appointmentId', getCurrentUser, async (req, res) => {
+  try {
+    const { appointmentId } = req.params;
+    
+    if (!isValidObjectId(appointmentId)) {
+      return res.status(400).json({ detail: 'Invalid appointment ID format' });
+    }
+    
+    const appointment = await appointmentService.getAppointment(appointmentId);
+    
+    if (!appointment) {
+      return res.status(404).json({ detail: 'Appointment not found' });
+    }
+    
+    res.json(appointment);
+  } catch (error) {
+    res.status(500).json({ detail: `Error fetching appointment: ${error.message}` });
+  }
+});
+
+/**
+ * PUT /api/appointments/:appointmentId
+ * Update an appointment
+ */
+router.put('/appointments/:appointmentId', requireStaff, async (req, res) => {
+  try {
+    const { appointmentId } = req.params;
+    const updateData = req.body;
+    
+    if (!isValidObjectId(appointmentId)) {
+      return res.status(400).json({ detail: 'Invalid appointment ID format' });
+    }
+    
+    // Check for conflicts if time is being updated
+    const existing = await appointmentService.getAppointment(appointmentId);
+    if (!existing) {
+      return res.status(404).json({ detail: 'Appointment not found' });
+    }
+    
+    if (updateData.date_time && existing.doctor_id) {
+      const conflicts = await appointmentService.checkConflicts(
+        existing.doctor_id,
+        updateData.date_time,
+        updateData.duration_minutes || existing.duration_minutes || 30,
+        appointmentId
+      );
+      
+      if (conflicts.length > 0) {
+        return res.status(409).json({
+          detail: {
+            message: 'Scheduling conflict detected',
+            conflicts
+          }
+        });
+      }
+    }
+    
+    const appointment = await appointmentService.updateAppointment(appointmentId, updateData);
+    
+    if (!appointment) {
+      return res.status(404).json({ detail: 'Appointment not found' });
+    }
+    
+    res.json(appointment);
+  } catch (error) {
+    res.status(500).json({ detail: `Error updating appointment: ${error.message}` });
+  }
+});
+
+/**
+ * POST /api/appointments/:appointmentId/cancel
+ * Cancel an appointment
+ */
+router.post('/appointments/:appointmentId/cancel', requireStaff, async (req, res) => {
+  try {
+    const { appointmentId } = req.params;
+    const { reason } = req.body || {};
+    
+    if (!isValidObjectId(appointmentId)) {
+      return res.status(400).json({ detail: 'Invalid appointment ID format' });
+    }
+    
+    const appointment = await appointmentService.cancelAppointment(appointmentId, reason);
+    
+    if (!appointment) {
+      return res.status(404).json({ detail: 'Appointment not found' });
+    }
+    
+    res.json(appointment);
+  } catch (error) {
+    res.status(500).json({ detail: `Error cancelling appointment: ${error.message}` });
+  }
+});
+
+/**
+ * POST /api/appointments/:appointmentId/complete
+ * Mark an appointment as completed
+ */
+router.post('/appointments/:appointmentId/complete', requireStaff, async (req, res) => {
+  try {
+    const { appointmentId } = req.params;
+    const { notes } = req.body || {};
+    
+    if (!isValidObjectId(appointmentId)) {
+      return res.status(400).json({ detail: 'Invalid appointment ID format' });
+    }
+    
+    const appointment = await appointmentService.completeAppointment(appointmentId, notes);
+    
+    if (!appointment) {
+      return res.status(404).json({ detail: 'Appointment not found' });
+    }
+    
+    res.json(appointment);
+  } catch (error) {
+    res.status(500).json({ detail: `Error completing appointment: ${error.message}` });
+  }
+});
+
+/**
+ * GET /api/appointments/:appointmentId/summary
+ * Generate an AI-powered pre-appointment summary
+ */
+router.get('/appointments/:appointmentId/summary', requireStaff, async (req, res) => {
+  try {
+    const { appointmentId } = req.params;
+    
+    if (!isValidObjectId(appointmentId)) {
+      return res.status(400).json({ detail: 'Invalid appointment ID format' });
+    }
+    
+    const summary = await appointmentService.generatePreAppointmentSummary(appointmentId);
+    
+    if (summary.error) {
+      return res.status(500).json({ detail: summary.error });
+    }
+    
+    res.json(summary);
+  } catch (error) {
+    res.status(500).json({ detail: `Error generating summary: ${error.message}` });
+  }
+});
+
+/**
+ * GET /api/patients/:patientId/appointments
+ * Get all appointments for a specific patient
+ */
+router.get('/patients/:patientId/appointments', getCurrentUser, async (req, res) => {
+  try {
+    const { patientId } = req.params;
+    const { include_past = 'false' } = req.query;
+    
+    if (!isValidObjectId(patientId)) {
+      return res.status(400).json({ detail: 'Invalid patient ID format' });
+    }
+    
+    const appointments = await appointmentService.getPatientAppointments(
+      patientId,
+      include_past === 'true'
+    );
+    
+    res.json(appointments);
+  } catch (error) {
+    res.status(500).json({ detail: `Error fetching appointments: ${error.message}` });
+  }
+});
+
+export default router;
+

routes/auth.js

@@ -0,0 +1,166 @@
+import express from 'express';
+import { authService, ACCESS_TOKEN_EXPIRE_MINUTES } from '../services/authService.js';
+import { getCurrentUser, requireDoctor, UserRole } from '../middleware/auth.js';
+import { ObjectId, getUsersCollection } from '../db/mongo.js';
+
+const router = express.Router();
+
+/**
+ * POST /api/auth/register
+ * Register a new user account
+ */
+router.post('/register', async (req, res) => {
+  try {
+    const { email, name, password, role = 'doctor' } = req.body;
+    
+    // Validation
+    if (!email || !name || !password) {
+      return res.status(400).json({ detail: 'Email, name, and password are required' });
+    }
+    
+    if (password.length < 6) {
+      return res.status(400).json({ detail: 'Password must be at least 6 characters' });
+    }
+    
+    // Validate role - only doctor and patient allowed
+    const validRoles = [UserRole.DOCTOR, UserRole.PATIENT];
+    if (!validRoles.includes(role)) {
+      return res.status(400).json({ detail: 'Invalid role. Must be "doctor" or "patient"' });
+    }
+    
+    const user = await authService.createUser({ email, name, password, role });
+    res.status(201).json(authService.userToResponse(user));
+  } catch (error) {
+    if (error.message.includes('already exists')) {
+      return res.status(400).json({ detail: error.message });
+    }
+    res.status(500).json({ detail: `Error creating user: ${error.message}` });
+  }
+});
+
+/**
+ * POST /api/auth/login
+ * Authenticate and receive a JWT token
+ */
+router.post('/login', async (req, res) => {
+  try {
+    const { email, password } = req.body;
+    
+    if (!email || !password) {
+      return res.status(400).json({ detail: 'Email and password are required' });
+    }
+    
+    const user = await authService.authenticateUser(email, password);
+    
+    if (!user) {
+      return res.status(401).json({
+        detail: 'Incorrect email or password',
+        headers: { 'WWW-Authenticate': 'Bearer' }
+      });
+    }
+    
+    if (!user.is_active) {
+      return res.status(403).json({ detail: 'User account is disabled' });
+    }
+    
+    // Create access token
+    const accessToken = authService.createAccessToken({
+      sub: user._id.toString(),
+      email: user.email,
+      role: user.role
+    });
+    
+    res.json({
+      access_token: accessToken,
+      token_type: 'bearer'
+    });
+  } catch (error) {
+    res.status(500).json({ detail: `Error during login: ${error.message}` });
+  }
+});
+
+/**
+ * GET /api/auth/me
+ * Get the current authenticated user's profile
+ */
+router.get('/me', getCurrentUser, async (req, res) => {
+  res.json(authService.userToResponse(req.user));
+});
+
+/**
+ * PUT /api/auth/me
+ * Update the current authenticated user's profile
+ */
+router.put('/me', getCurrentUser, async (req, res) => {
+  try {
+    const { name, role } = req.body;
+    const updateData = {};
+    
+    if (name) updateData.name = name;
+    if (role) updateData.role = role;
+    
+    const updatedUser = await authService.updateUser(req.user._id.toString(), updateData);
+    
+    if (!updatedUser) {
+      return res.status(404).json({ detail: 'User not found' });
+    }
+    
+    res.json(authService.userToResponse(updatedUser));
+  } catch (error) {
+    res.status(500).json({ detail: `Error updating user: ${error.message}` });
+  }
+});
+
+/**
+ * POST /api/auth/logout
+ * Logout the current user
+ */
+router.post('/logout', getCurrentUser, async (req, res) => {
+  res.json({
+    message: 'Successfully logged out',
+    user_id: req.user._id.toString()
+  });
+});
+
+/**
+ * GET /api/auth/users
+ * List all users (Doctor only)
+ */
+router.get('/users', requireDoctor, async (req, res) => {
+  try {
+    const usersCollection = getUsersCollection();
+    const users = await usersCollection.find().toArray();
+    res.json(users.map(user => authService.userToResponse(user)));
+  } catch (error) {
+    res.status(500).json({ detail: `Error fetching users: ${error.message}` });
+  }
+});
+
+/**
+ * DELETE /api/auth/users/:userId
+ * Delete a user (Doctor only)
+ */
+router.delete('/users/:userId', requireDoctor, async (req, res) => {
+  try {
+    const { userId } = req.params;
+    
+    // Prevent self-deletion
+    if (req.user._id.toString() === userId) {
+      return res.status(400).json({ detail: 'Cannot delete your own account' });
+    }
+    
+    const usersCollection = getUsersCollection();
+    const result = await usersCollection.deleteOne({ _id: new ObjectId(userId) });
+    
+    if (result.deletedCount === 0) {
+      return res.status(404).json({ detail: 'User not found' });
+    }
+    
+    res.json({ message: 'User deleted successfully', id: userId });
+  } catch (error) {
+    res.status(500).json({ detail: `Error deleting user: ${error.message}` });
+  }
+});
+
+export default router;
+

routes/patients.js

@@ -0,0 +1,431 @@
+import express from 'express';
+import { ObjectId, getPatientsCollection } from '../db/mongo.js';
+import { summarizePatient } from '../services/aiService.js';
+import { ragService } from '../services/ragService.js';
+import { vectorService } from '../services/vectorService.js';
+import { timelineService } from '../services/timelineService.js';
+
+const router = express.Router();
+
+/**
+ * Helper to format patient document for response
+ */
+const patientHelper = (patient) => ({
+  _id: patient._id.toString(),
+  name: patient.name || '',
+  age: patient.age || 0,
+  gender: patient.gender || '',
+  medical_history: patient.medical_history || [],
+  medications: patient.medications || [],
+  date_of_birth: patient.date_of_birth || null,
+  allergies: patient.allergies || [],
+  blood_type: patient.blood_type || null,
+  notes: patient.notes || null
+});
+
+/**
+ * Validate ObjectId format
+ */
+const isValidObjectId = (id) => {
+  try {
+    return ObjectId.isValid(id) && new ObjectId(id).toString() === id;
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * POST /api/patients/
+ * Create a new patient
+ */
+router.post('/patients/', async (req, res) => {
+  try {
+    const patientsCollection = getPatientsCollection();
+    const patientData = req.body;
+    
+    // Validation
+    if (!patientData.name || patientData.name.length < 1) {
+      return res.status(400).json({ detail: 'Name is required' });
+    }
+    if (patientData.age === undefined || patientData.age < 0 || patientData.age > 150) {
+      return res.status(400).json({ detail: 'Valid age (0-150) is required' });
+    }
+    
+    const result = await patientsCollection.insertOne(patientData);
+    const patientId = result.insertedId.toString();
+    
+    // Index patient data in vector database
+    try {
+      await vectorService.addPatientRecord(patientId, patientData);
+    } catch (error) {
+      console.log(`Warning: Failed to index patient in vector DB: ${error.message}`);
+    }
+    
+    res.status(201).json({ id: patientId, message: 'Patient created successfully' });
+  } catch (error) {
+    res.status(400).json({ detail: `Error creating patient: ${error.message}` });
+  }
+});
+
+/**
+ * GET /api/patients/
+ * List all patients
+ */
+router.get('/patients/', async (req, res) => {
+  try {
+    const patientsCollection = getPatientsCollection();
+    const patients = await patientsCollection.find().toArray();
+    res.json(patients.map(patientHelper));
+  } catch (error) {
+    res.status(500).json({ detail: `Error fetching patients: ${error.message}` });
+  }
+});
+
+/**
+ * GET /api/patients/search/semantic
+ * Semantic search across patients
+ */
+router.get('/patients/search/semantic', async (req, res) => {
+  try {
+    const { query, limit = 5 } = req.query;
+    
+    if (!query) {
+      return res.status(400).json({ detail: 'Query parameter is required' });
+    }
+    
+    const results = await vectorService.searchPatientRecords(query, null, parseInt(limit));
+    res.json({
+      query,
+      results,
+      count: results.length
+    });
+  } catch (error) {
+    res.status(500).json({ detail: `Error performing semantic search: ${error.message}` });
+  }
+});
+
+/**
+ * GET /api/patients/:patientId
+ * Get a specific patient
+ */
+router.get('/patients/:patientId', async (req, res) => {
+  try {
+    const { patientId } = req.params;
+    
+    if (!isValidObjectId(patientId)) {
+      return res.status(400).json({ detail: 'Invalid patient ID format' });
+    }
+    
+    const patientsCollection = getPatientsCollection();
+    const patient = await patientsCollection.findOne({ _id: new ObjectId(patientId) });
+    
+    if (!patient) {
+      return res.status(404).json({ detail: 'Patient not found' });
+    }
+    
+    res.json(patientHelper(patient));
+  } catch (error) {
+    res.status(500).json({ detail: `Error fetching patient: ${error.message}` });
+  }
+});
+
+/**
+ * PUT /api/patients/:patientId
+ * Update a patient
+ */
+router.put('/patients/:patientId', async (req, res) => {
+  try {
+    const { patientId } = req.params;
+    
+    if (!isValidObjectId(patientId)) {
+      return res.status(400).json({ detail: 'Invalid patient ID format' });
+    }
+    
+    const patientsCollection = getPatientsCollection();
+    const updateData = req.body;
+    
+    const result = await patientsCollection.updateOne(
+      { _id: new ObjectId(patientId) },
+      { $set: updateData }
+    );
+    
+    if (result.matchedCount === 0) {
+      return res.status(404).json({ detail: 'Patient not found' });
+    }
+    
+    const updatedPatient = await patientsCollection.findOne({ _id: new ObjectId(patientId) });
+    
+    // Re-index patient data in vector database
+    try {
+      await vectorService.deletePatientRecords(patientId);
+      await vectorService.addPatientRecord(patientId, patientHelper(updatedPatient));
+    } catch (error) {
+      console.log(`Warning: Failed to re-index patient in vector DB: ${error.message}`);
+    }
+    
+    res.json(patientHelper(updatedPatient));
+  } catch (error) {
+    res.status(500).json({ detail: `Error updating patient: ${error.message}` });
+  }
+});
+
+/**
+ * DELETE /api/patients/:patientId
+ * Delete a patient
+ */
+router.delete('/patients/:patientId', async (req, res) => {
+  try {
+    const { patientId } = req.params;
+    
+    if (!isValidObjectId(patientId)) {
+      return res.status(400).json({ detail: 'Invalid patient ID format' });
+    }
+    
+    const patientsCollection = getPatientsCollection();
+    const result = await patientsCollection.deleteOne({ _id: new ObjectId(patientId) });
+    
+    if (result.deletedCount === 0) {
+      return res.status(404).json({ detail: 'Patient not found' });
+    }
+    
+    res.json({ message: 'Patient deleted successfully', id: patientId });
+  } catch (error) {
+    res.status(500).json({ detail: `Error deleting patient: ${error.message}` });
+  }
+});
+
+/**
+ * GET /api/patients/:patientId/summary
+ * Get AI-generated patient summary
+ */
+router.get('/patients/:patientId/summary', async (req, res) => {
+  try {
+    const { patientId } = req.params;
+    const { query } = req.query;
+    
+    if (!query) {
+      return res.status(400).json({ detail: 'Query parameter is required' });
+    }
+    
+    if (!isValidObjectId(patientId)) {
+      return res.status(400).json({ detail: 'Invalid patient ID format' });
+    }
+    
+    const patientsCollection = getPatientsCollection();
+    const patient = await patientsCollection.findOne({ _id: new ObjectId(patientId) });
+    
+    if (!patient) {
+      return res.status(404).json({ detail: 'Patient not found' });
+    }
+    
+    const summary = await summarizePatient(patient, query);
+    res.json(summary);
+  } catch (error) {
+    res.status(500).json({ detail: `Error generating summary: ${error.message}` });
+  }
+});
+
+/**
+ * GET /api/patients/:patientId/rag-summary
+ * Get RAG-enhanced patient summary
+ */
+router.get('/patients/:patientId/rag-summary', async (req, res) => {
+  try {
+    const { patientId } = req.params;
+    const { query } = req.query;
+    
+    if (!query) {
+      return res.status(400).json({ detail: 'Query parameter is required' });
+    }
+    
+    if (!isValidObjectId(patientId)) {
+      return res.status(400).json({ detail: 'Invalid patient ID format' });
+    }
+    
+    const patientsCollection = getPatientsCollection();
+    const patient = await patientsCollection.findOne({ _id: new ObjectId(patientId) });
+    
+    if (!patient) {
+      return res.status(404).json({ detail: 'Patient not found' });
+    }
+    
+    patient._id = patient._id.toString();
+    const summary = await ragService.generateRAGResponse(patientId, patient, query);
+    res.json(summary);
+  } catch (error) {
+    res.status(500).json({ detail: `Error generating RAG summary: ${error.message}` });
+  }
+});
+
+/**
+ * GET /api/patients/:patientId/suggest-treatment
+ * Get treatment suggestions for a condition
+ */
+router.get('/patients/:patientId/suggest-treatment', async (req, res) => {
+  try {
+    const { patientId } = req.params;
+    const { condition } = req.query;
+    
+    if (!condition) {
+      return res.status(400).json({ detail: 'Condition parameter is required' });
+    }
+    
+    if (!isValidObjectId(patientId)) {
+      return res.status(400).json({ detail: 'Invalid patient ID format' });
+    }
+    
+    const patientsCollection = getPatientsCollection();
+    const patient = await patientsCollection.findOne({ _id: new ObjectId(patientId) });
+    
+    if (!patient) {
+      return res.status(404).json({ detail: 'Patient not found' });
+    }
+    
+    patient._id = patient._id.toString();
+    const suggestions = await ragService.suggestTreatments(patientId, patient, condition);
+    res.json(suggestions);
+  } catch (error) {
+    res.status(500).json({ detail: `Error suggesting treatment: ${error.message}` });
+  }
+});
+
+/**
+ * GET /api/patients/:patientId/drug-interactions
+ * Analyze drug interactions for new medication
+ */
+router.get('/patients/:patientId/drug-interactions', async (req, res) => {
+  try {
+    const { patientId } = req.params;
+    const { new_medication } = req.query;
+    
+    if (!new_medication) {
+      return res.status(400).json({ detail: 'new_medication parameter is required' });
+    }
+    
+    if (!isValidObjectId(patientId)) {
+      return res.status(400).json({ detail: 'Invalid patient ID format' });
+    }
+    
+    const patientsCollection = getPatientsCollection();
+    const patient = await patientsCollection.findOne({ _id: new ObjectId(patientId) });
+    
+    if (!patient) {
+      return res.status(404).json({ detail: 'Patient not found' });
+    }
+    
+    patient._id = patient._id.toString();
+    const analysis = await ragService.analyzeDrugInteractions(patientId, patient, new_medication);
+    res.json(analysis);
+  } catch (error) {
+    res.status(500).json({ detail: `Error analyzing drug interactions: ${error.message}` });
+  }
+});
+
+/**
+ * GET /api/vector-db/stats
+ * Get vector database statistics
+ */
+router.get('/vector-db/stats', async (req, res) => {
+  try {
+    const stats = await vectorService.getCollectionStats();
+    res.json(stats);
+  } catch (error) {
+    res.status(500).json({ detail: `Error fetching stats: ${error.message}` });
+  }
+});
+
+/**
+ * POST /api/vector-db/reindex
+ * Reindex all patients into the vector database
+ */
+router.post('/vector-db/reindex', async (req, res) => {
+  try {
+    const patientsCollection = getPatientsCollection();
+    const patients = await patientsCollection.find().toArray();
+    let indexedCount = 0;
+    const errors = [];
+    
+    for (const patient of patients) {
+      try {
+        const patientId = patient._id.toString();
+        const patientData = patientHelper(patient);
+        await vectorService.deletePatientRecords(patientId);
+        await vectorService.addPatientRecord(patientId, patientData);
+        indexedCount++;
+      } catch (error) {
+        errors.push(`${patient.name || 'Unknown'}: ${error.message}`);
+      }
+    }
+    
+    res.json({
+      message: `Reindexed ${indexedCount} patients`,
+      total_patients: patients.length,
+      indexed: indexedCount,
+      errors: errors.length > 0 ? errors : null
+    });
+  } catch (error) {
+    res.status(500).json({ detail: `Error reindexing: ${error.message}` });
+  }
+});
+
+// Timeline Routes
+
+/**
+ * GET /api/patients/:patientId/timeline
+ * Get the complete timeline of events for a patient
+ */
+router.get('/patients/:patientId/timeline', async (req, res) => {
+  try {
+    const { patientId } = req.params;
+    
+    if (!isValidObjectId(patientId)) {
+      return res.status(400).json({ detail: 'Invalid patient ID format' });
+    }
+    
+    const timeline = await timelineService.getPatientTimeline(patientId);
+    res.json({ patient_id: patientId, events: timeline, count: timeline.length });
+  } catch (error) {
+    res.status(500).json({ detail: `Error fetching timeline: ${error.message}` });
+  }
+});
+
+/**
+ * GET /api/patients/:patientId/timeline/summary
+ * Get an AI-generated summary of the patient's medical timeline
+ */
+router.get('/patients/:patientId/timeline/summary', async (req, res) => {
+  try {
+    const { patientId } = req.params;
+    
+    if (!isValidObjectId(patientId)) {
+      return res.status(400).json({ detail: 'Invalid patient ID format' });
+    }
+    
+    const summary = await timelineService.generateTimelineSummary(patientId);
+    res.json(summary);
+  } catch (error) {
+    res.status(500).json({ detail: `Error generating timeline summary: ${error.message}` });
+  }
+});
+
+/**
+ * GET /api/patients/:patientId/timeline/stats
+ * Get statistics about the patient's timeline
+ */
+router.get('/patients/:patientId/timeline/stats', async (req, res) => {
+  try {
+    const { patientId } = req.params;
+    
+    if (!isValidObjectId(patientId)) {
+      return res.status(400).json({ detail: 'Invalid patient ID format' });
+    }
+    
+    const stats = await timelineService.getTimelineStats(patientId);
+    res.json(stats);
+  } catch (error) {
+    res.status(500).json({ detail: `Error fetching timeline stats: ${error.message}` });
+  }
+});
+
+export default router;
+

routes/warnings.js

@@ -0,0 +1,145 @@
+import express from 'express';
+import { ObjectId } from '../db/mongo.js';
+import { warningService } from '../services/warningService.js';
+import { getCurrentUser, requireStaff } from '../middleware/auth.js';
+
+const router = express.Router();
+
+/**
+ * Validate ObjectId format
+ */
+const isValidObjectId = (id) => {
+  try {
+    return ObjectId.isValid(id) && new ObjectId(id).toString() === id;
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * GET /api/patients/:patientId/warnings
+ * Get all clinical warnings for a specific patient
+ */
+router.get('/patients/:patientId/warnings', getCurrentUser, async (req, res) => {
+  try {
+    const { patientId } = req.params;
+    const { include_acknowledged = 'false' } = req.query;
+    
+    if (!isValidObjectId(patientId)) {
+      return res.status(400).json({ detail: 'Invalid patient ID format' });
+    }
+    
+    const warnings = await warningService.getPatientWarnings(
+      patientId,
+      include_acknowledged === 'true'
+    );
+    
+    res.json(warnings);
+  } catch (error) {
+    res.status(500).json({ detail: `Error fetching warnings: ${error.message}` });
+  }
+});
+
+/**
+ * POST /api/patients/:patientId/warnings/analyze
+ * Trigger AI analysis to generate clinical warnings for a patient
+ */
+router.post('/patients/:patientId/warnings/analyze', requireStaff, async (req, res) => {
+  try {
+    const { patientId } = req.params;
+    const { new_medication, new_condition } = req.body || {};
+    
+    if (!isValidObjectId(patientId)) {
+      return res.status(400).json({ detail: 'Invalid patient ID format' });
+    }
+    
+    const warnings = await warningService.analyzePatientForWarnings(
+      patientId,
+      new_medication,
+      new_condition
+    );
+    
+    res.json(warnings);
+  } catch (error) {
+    res.status(500).json({ detail: `Error analyzing patient: ${error.message}` });
+  }
+});
+
+/**
+ * PUT /api/warnings/:warningId/acknowledge
+ * Acknowledge a clinical warning
+ */
+router.put('/warnings/:warningId/acknowledge', requireStaff, async (req, res) => {
+  try {
+    const { warningId } = req.params;
+    const { notes } = req.body || {};
+    
+    if (!isValidObjectId(warningId)) {
+      return res.status(400).json({ detail: 'Invalid warning ID format' });
+    }
+    
+    const userId = req.user._id.toString();
+    const warning = await warningService.acknowledgeWarning(warningId, userId, notes);
+    
+    if (!warning) {
+      return res.status(404).json({ detail: 'Warning not found' });
+    }
+    
+    res.json(warning);
+  } catch (error) {
+    res.status(500).json({ detail: `Error acknowledging warning: ${error.message}` });
+  }
+});
+
+/**
+ * GET /api/warnings/unacknowledged
+ * Get all unacknowledged warnings across all patients
+ */
+router.get('/warnings/unacknowledged', getCurrentUser, async (req, res) => {
+  try {
+    const { limit = 50 } = req.query;
+    
+    const warnings = await warningService.getAllUnacknowledgedWarnings(
+      Math.min(parseInt(limit), 100)
+    );
+    
+    res.json(warnings);
+  } catch (error) {
+    res.status(500).json({ detail: `Error fetching warnings: ${error.message}` });
+  }
+});
+
+/**
+ * GET /api/warnings/stats
+ * Get warning statistics
+ */
+router.get('/warnings/stats', getCurrentUser, async (req, res) => {
+  try {
+    const stats = await warningService.getWarningStats();
+    res.json(stats);
+  } catch (error) {
+    res.status(500).json({ detail: `Error fetching stats: ${error.message}` });
+  }
+});
+
+/**
+ * DELETE /api/patients/:patientId/warnings
+ * Delete all warnings for a patient (Staff only)
+ */
+router.delete('/patients/:patientId/warnings', requireStaff, async (req, res) => {
+  try {
+    const { patientId } = req.params;
+    
+    if (!isValidObjectId(patientId)) {
+      return res.status(400).json({ detail: 'Invalid patient ID format' });
+    }
+    
+    const deletedCount = await warningService.deletePatientWarnings(patientId);
+    res.json({ message: `Deleted ${deletedCount} warnings`, deleted_count: deletedCount });
+  } catch (error) {
+    res.status(500).json({ detail: `Error deleting warnings: ${error.message}` });
+  }
+});
+
+export default router;
+

services/aiService.js

@@ -0,0 +1,22 @@
+import { generateResponse } from './llmClient.js';
+
+/**
+ * Summarize patient data based on a query using LLM
+ */
+export const summarizePatient = async (patientData, query) => {
+  const prompt = `
+    You are a medical assistant AI.
+    Analyze the following patient data and answer the query in a concise,
+    structured, and professional format.
+
+    Patient data: ${JSON.stringify(patientData)}
+    Question: ${query}
+  `;
+  
+  try {
+    const content = await generateResponse(prompt);
+    return { content, role: 'assistant' };
+  } catch (error) {
+    return { content: `Error generating summary: ${error.message}`, error: true };
+  }
+};

services/appointmentService.js

@@ -0,0 +1,419 @@
+import { generateResponse } from './llmClient.js';
+import { ObjectId, getAppointmentsCollection, getPatientsCollection, getUsersCollection } from '../db/mongo.js';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+// Appointment status enum
+export const AppointmentStatus = {
+  SCHEDULED: 'scheduled',
+  CONFIRMED: 'confirmed',
+  IN_PROGRESS: 'in_progress',
+  COMPLETED: 'completed',
+  CANCELLED: 'cancelled',
+  NO_SHOW: 'no_show'
+};
+
+class AppointmentService {
+  /**
+   * Convert MongoDB appointment document to response format
+   */
+  _appointmentHelper(appointment) {
+    return {
+      id: appointment._id.toString(),
+      patient_id: appointment.patient_id,
+      doctor_id: appointment.doctor_id || null,
+      date_time: appointment.date_time,
+      duration_minutes: appointment.duration_minutes || 30,
+      appointment_type: appointment.appointment_type || 'checkup',
+      purpose: appointment.purpose || '',
+      notes: appointment.notes || null,
+      location: appointment.location || null,
+      status: appointment.status || 'scheduled',
+      created_at: appointment.created_at,
+      updated_at: appointment.updated_at,
+      created_by: appointment.created_by || '',
+      cancelled_reason: appointment.cancelled_reason || null,
+      patient_name: appointment.patient_name || null,
+      doctor_name: appointment.doctor_name || null
+    };
+  }
+  
+  /**
+   * Add patient and doctor names to appointment
+   */
+  async _enrichWithNames(appointment) {
+    const patientsCollection = getPatientsCollection();
+    const usersCollection = getUsersCollection();
+    
+    // Get patient name
+    try {
+      const patient = await patientsCollection.findOne({ _id: new ObjectId(appointment.patient_id) });
+      appointment.patient_name = patient ? patient.name : null;
+    } catch {
+      appointment.patient_name = null;
+    }
+    
+    // Get doctor name
+    if (appointment.doctor_id) {
+      try {
+        const doctor = await usersCollection.findOne({ _id: new ObjectId(appointment.doctor_id) });
+        appointment.doctor_name = doctor ? doctor.name : null;
+      } catch {
+        appointment.doctor_name = null;
+      }
+    }
+    
+    return appointment;
+  }
+  
+  /**
+   * Create a new appointment
+   */
+  async createAppointment(appointmentData, userId) {
+    const appointmentsCollection = getAppointmentsCollection();
+    const now = new Date();
+    
+    const appointmentDoc = {
+      ...appointmentData,
+      status: AppointmentStatus.SCHEDULED,
+      created_at: now,
+      updated_at: now,
+      created_by: userId
+    };
+    
+    const result = await appointmentsCollection.insertOne(appointmentDoc);
+    appointmentDoc._id = result.insertedId;
+    const enriched = await this._enrichWithNames(appointmentDoc);
+    
+    return this._appointmentHelper(enriched);
+  }
+  
+  /**
+   * Get a single appointment by ID
+   */
+  async getAppointment(appointmentId) {
+    try {
+      const appointmentsCollection = getAppointmentsCollection();
+      const appointment = await appointmentsCollection.findOne({ _id: new ObjectId(appointmentId) });
+      
+      if (appointment) {
+        const enriched = await this._enrichWithNames(appointment);
+        return this._appointmentHelper(enriched);
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  
+  /**
+   * List appointments with optional filters
+   */
+  async listAppointments({ patientId, doctorId, status, fromDate, toDate, limit = 50 }) {
+    const appointmentsCollection = getAppointmentsCollection();
+    const query = {};
+    
+    if (patientId) query.patient_id = patientId;
+    if (doctorId) query.doctor_id = doctorId;
+    if (status) query.status = status;
+    
+    if (fromDate || toDate) {
+      query.date_time = {};
+      if (fromDate) query.date_time.$gte = fromDate;
+      if (toDate) query.date_time.$lte = toDate;
+    }
+    
+    const appointments = await appointmentsCollection
+      .find(query)
+      .sort({ date_time: 1 })
+      .limit(limit)
+      .toArray();
+    
+    const result = [];
+    for (const apt of appointments) {
+      const enriched = await this._enrichWithNames(apt);
+      result.push(this._appointmentHelper(enriched));
+    }
+    
+    return result;
+  }
+  
+  /**
+   * Get upcoming appointments
+   */
+  async getUpcomingAppointments(limit = 20) {
+    const appointmentsCollection = getAppointmentsCollection();
+    const now = new Date().toISOString();
+    
+    const appointments = await appointmentsCollection
+      .find({
+        date_time: { $gte: now },
+        status: { $in: ['scheduled', 'confirmed'] }
+      })
+      .sort({ date_time: 1 })
+      .limit(limit)
+      .toArray();
+    
+    const result = [];
+    for (const apt of appointments) {
+      const enriched = await this._enrichWithNames(apt);
+      result.push(this._appointmentHelper(enriched));
+    }
+    
+    return result;
+  }
+  
+  /**
+   * Get all appointments for a specific patient
+   */
+  async getPatientAppointments(patientId, includePast = false) {
+    const appointmentsCollection = getAppointmentsCollection();
+    const query = { patient_id: patientId };
+    
+    if (!includePast) {
+      const now = new Date().toISOString();
+      query.$or = [
+        { date_time: { $gte: now } },
+        { status: { $in: ['scheduled', 'confirmed'] } }
+      ];
+    }
+    
+    const appointments = await appointmentsCollection
+      .find(query)
+      .sort({ date_time: -1 })
+      .toArray();
+    
+    const result = [];
+    for (const apt of appointments) {
+      const enriched = await this._enrichWithNames(apt);
+      result.push(this._appointmentHelper(enriched));
+    }
+    
+    return result;
+  }
+  
+  /**
+   * Update an appointment
+   */
+  async updateAppointment(appointmentId, updateData) {
+    const appointmentsCollection = getAppointmentsCollection();
+    const updateDict = { ...updateData, updated_at: new Date() };
+    
+    const result = await appointmentsCollection.updateOne(
+      { _id: new ObjectId(appointmentId) },
+      { $set: updateDict }
+    );
+    
+    if (result.matchedCount === 0) {
+      return null;
+    }
+    
+    return await this.getAppointment(appointmentId);
+  }
+  
+  /**
+   * Cancel an appointment
+   */
+  async cancelAppointment(appointmentId, reason = null) {
+    const appointmentsCollection = getAppointmentsCollection();
+    
+    const result = await appointmentsCollection.updateOne(
+      { _id: new ObjectId(appointmentId) },
+      {
+        $set: {
+          status: AppointmentStatus.CANCELLED,
+          cancelled_reason: reason,
+          updated_at: new Date()
+        }
+      }
+    );
+    
+    if (result.matchedCount === 0) {
+      return null;
+    }
+    
+    return await this.getAppointment(appointmentId);
+  }
+  
+  /**
+   * Mark an appointment as completed
+   */
+  async completeAppointment(appointmentId, notes = null) {
+    const appointmentsCollection = getAppointmentsCollection();
+    const updateData = {
+      status: AppointmentStatus.COMPLETED,
+      updated_at: new Date()
+    };
+    
+    if (notes) {
+      updateData.notes = notes;
+    }
+    
+    const result = await appointmentsCollection.updateOne(
+      { _id: new ObjectId(appointmentId) },
+      { $set: updateData }
+    );
+    
+    if (result.matchedCount === 0) {
+      return null;
+    }
+    
+    return await this.getAppointment(appointmentId);
+  }
+  
+  /**
+   * Check for scheduling conflicts
+   */
+  async checkConflicts(doctorId, dateTime, durationMinutes, excludeId = null) {
+    const appointmentsCollection = getAppointmentsCollection();
+    
+    // Parse the proposed datetime
+    let proposedStart, proposedEnd;
+    try {
+      proposedStart = new Date(dateTime.replace('Z', '+00:00'));
+      proposedEnd = new Date(proposedStart.getTime() + durationMinutes * 60000);
+    } catch {
+      return [];
+    }
+    
+    // Find overlapping appointments
+    const query = {
+      doctor_id: doctorId,
+      status: { $in: ['scheduled', 'confirmed'] }
+    };
+    
+    if (excludeId) {
+      query._id = { $ne: new ObjectId(excludeId) };
+    }
+    
+    const appointments = await appointmentsCollection.find(query).toArray();
+    
+    const conflicts = [];
+    for (const apt of appointments) {
+      try {
+        const aptStart = new Date(apt.date_time.replace('Z', '+00:00'));
+        const aptEnd = new Date(aptStart.getTime() + (apt.duration_minutes || 30) * 60000);
+        
+        // Check for overlap
+        if (!(proposedEnd <= aptStart || proposedStart >= aptEnd)) {
+          conflicts.push(this._appointmentHelper(apt));
+        }
+      } catch {
+        continue;
+      }
+    }
+    
+    return conflicts;
+  }
+  
+  /**
+   * Generate an AI-powered pre-appointment summary
+   */
+  async generatePreAppointmentSummary(appointmentId) {
+    const appointmentsCollection = getAppointmentsCollection();
+    const patientsCollection = getPatientsCollection();
+    
+    const appointment = await appointmentsCollection.findOne({ _id: new ObjectId(appointmentId) });
+    if (!appointment) {
+      return { error: 'Appointment not found' };
+    }
+    
+    // Get patient data
+    const patient = await patientsCollection.findOne({ _id: new ObjectId(appointment.patient_id) });
+    if (!patient) {
+      return { error: 'Patient not found' };
+    }
+    
+    // Build context
+    const medicalHistory = patient.medical_history || [];
+    const historyText = medicalHistory.map(item => {
+      if (typeof item === 'string') return `- ${item}`;
+      return `- ${item.condition || 'Unknown'}`;
+    }).join('\n');
+    
+    const medications = patient.medications || [];
+    const medsText = medications.map(med => {
+      if (typeof med === 'object') {
+        return `- ${med.name || 'Unknown'}: ${med.dosage || 'N/A'}`;
+      }
+      return `- ${med}`;
+    }).join('\n');
+    
+    const prompt = `You are a medical AI assistant preparing a pre-appointment briefing for a doctor.
+
+UPCOMING APPOINTMENT:
+- Purpose: ${appointment.purpose || 'General checkup'}
+- Type: ${appointment.appointment_type || 'checkup'}
+- Notes: ${appointment.notes || 'None'}
+
+PATIENT INFORMATION:
+- Name: ${patient.name || 'Unknown'}
+- Age: ${patient.age || 'Unknown'}
+- Gender: ${patient.gender || 'Unknown'}
+- Blood Type: ${patient.blood_type || 'Unknown'}
+- Allergies: ${(patient.allergies || []).join(', ') || 'None recorded'}
+
+MEDICAL HISTORY:
+${historyText || 'No medical history recorded'}
+
+CURRENT MEDICATIONS:
+${medsText || 'No medications recorded'}
+
+Please provide a concise pre-appointment briefing including:
+1. **Patient Overview**: Quick summary of the patient
+2. **Key Concerns**: Important medical factors to consider
+3. **Suggested Focus Areas**: What to examine based on history
+4. **Questions to Ask**: Relevant questions for this appointment type
+5. **Precautions**: Any special considerations
+
+Keep it concise and actionable for a busy doctor.`;
+
+    try {
+      const summary = await generateResponse(prompt);
+      
+      return {
+        appointment_id: appointmentId,
+        patient_name: patient.name,
+        purpose: appointment.purpose,
+        summary,
+        generated_at: new Date().toISOString()
+      };
+    } catch (error) {
+      return { error: `Error generating summary: ${error.message}` };
+    }
+  }
+  
+  /**
+   * Get appointment statistics
+   */
+  async getAppointmentStats() {
+    const appointmentsCollection = getAppointmentsCollection();
+    
+    const pipeline = [
+      {
+        $group: {
+          _id: '$status',
+          count: { $sum: 1 }
+        }
+      }
+    ];
+    
+    const results = await appointmentsCollection.aggregate(pipeline).toArray();
+    
+    const stats = {
+      total: 0,
+      by_status: {}
+    };
+    
+    for (const r of results) {
+      stats.by_status[r._id] = r.count;
+      stats.total += r.count;
+    }
+    
+    return stats;
+  }
+}
+
+// Singleton instance
+export const appointmentService = new AppointmentService();

services/authService.js

@@ -0,0 +1,158 @@
+import jwt from 'jsonwebtoken';
+import bcrypt from 'bcryptjs';
+import { ObjectId, getUsersCollection } from '../db/mongo.js';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const SECRET_KEY = process.env.JWT_SECRET_KEY || 'your-super-secret-key-change-in-production';
+const ALGORITHM = 'HS256';
+export const ACCESS_TOKEN_EXPIRE_MINUTES = 60 * 24; // 24 hours
+
+class AuthService {
+  /**
+   * Verify a password against its hash
+   */
+  verifyPassword(plainPassword, hashedPassword) {
+    return bcrypt.compareSync(plainPassword, hashedPassword);
+  }
+  
+  /**
+   * Hash a password
+   */
+  getPasswordHash(password) {
+    const salt = bcrypt.genSaltSync(10);
+    return bcrypt.hashSync(password, salt);
+  }
+  
+  /**
+   * Create a JWT access token
+   */
+  createAccessToken(data, expiresInMinutes = ACCESS_TOKEN_EXPIRE_MINUTES) {
+    const payload = {
+      ...data,
+      exp: Math.floor(Date.now() / 1000) + (expiresInMinutes * 60)
+    };
+    return jwt.sign(payload, SECRET_KEY, { algorithm: ALGORITHM });
+  }
+  
+  /**
+   * Decode and validate a JWT token
+   */
+  decodeToken(token) {
+    try {
+      const payload = jwt.verify(token, SECRET_KEY, { algorithms: [ALGORITHM] });
+      const userId = payload.sub;
+      const email = payload.email;
+      const role = payload.role;
+      
+      if (!userId) {
+        return null;
+      }
+      
+      return { userId, email, role };
+    } catch (error) {
+      return null;
+    }
+  }
+  
+  /**
+   * Get a user by email
+   */
+  async getUserByEmail(email) {
+    const usersCollection = getUsersCollection();
+    return await usersCollection.findOne({ email });
+  }
+  
+  /**
+   * Get a user by ID
+   */
+  async getUserById(userId) {
+    try {
+      const usersCollection = getUsersCollection();
+      return await usersCollection.findOne({ _id: new ObjectId(userId) });
+    } catch (error) {
+      return null;
+    }
+  }
+  
+  /**
+   * Create a new user
+   */
+  async createUser(userData) {
+    const usersCollection = getUsersCollection();
+    
+    // Check if user already exists
+    const existingUser = await this.getUserByEmail(userData.email);
+    if (existingUser) {
+      throw new Error('User with this email already exists');
+    }
+    
+    // Create user document
+    const now = new Date();
+    const userDoc = {
+      email: userData.email,
+      name: userData.name,
+      role: userData.role || 'doctor',
+      hashed_password: this.getPasswordHash(userData.password),
+      created_at: now,
+      updated_at: now,
+      is_active: true
+    };
+    
+    const result = await usersCollection.insertOne(userDoc);
+    userDoc._id = result.insertedId;
+    return userDoc;
+  }
+  
+  /**
+   * Authenticate a user by email and password
+   */
+  async authenticateUser(email, password) {
+    const user = await this.getUserByEmail(email);
+    if (!user) {
+      return null;
+    }
+    if (!this.verifyPassword(password, user.hashed_password)) {
+      return null;
+    }
+    return user;
+  }
+  
+  /**
+   * Convert a user document to a response object
+   */
+  userToResponse(user) {
+    return {
+      id: user._id.toString(),
+      email: user.email,
+      name: user.name,
+      role: user.role,
+      created_at: user.created_at,
+      is_active: user.is_active !== false
+    };
+  }
+  
+  /**
+   * Update a user's information
+   */
+  async updateUser(userId, updateData) {
+    const usersCollection = getUsersCollection();
+    updateData.updated_at = new Date();
+    
+    const result = await usersCollection.updateOne(
+      { _id: new ObjectId(userId) },
+      { $set: updateData }
+    );
+    
+    if (result.matchedCount === 0) {
+      return null;
+    }
+    
+    return await this.getUserById(userId);
+  }
+}
+
+// Singleton instance
+export const authService = new AuthService();
+

services/llmClient.js

@@ -0,0 +1,57 @@
+import OpenAI from 'openai';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const client = new OpenAI({
+  baseURL: 'https://router.huggingface.co/v1',
+  apiKey: process.env.HF_TOKEN
+});
+
+const MODEL = 'meta-llama/Llama-3.2-3B-Instruct:novita';
+
+/**
+ * Generate a response using the Llama model
+ * @param {string} prompt - The prompt to send to the model
+ * @returns {Promise<string>} - The generated text response
+ */
+export const generateResponse = async (prompt) => {
+  const completion = await client.chat.completions.create({
+    model: MODEL,
+    messages: [
+      {
+        role: 'user',
+        content: prompt
+      }
+    ]
+  });
+  
+  return completion.choices[0].message.content;
+};
+
+/**
+ * Generate a response with system message
+ * @param {string} systemPrompt - The system message
+ * @param {string} userPrompt - The user message
+ * @returns {Promise<string>} - The generated text response
+ */
+export const generateResponseWithSystem = async (systemPrompt, userPrompt) => {
+  const completion = await client.chat.completions.create({
+    model: MODEL,
+    messages: [
+      {
+        role: 'system',
+        content: systemPrompt
+      },
+      {
+        role: 'user',
+        content: userPrompt
+      }
+    ]
+  });
+  
+  return completion.choices[0].message.content;
+};
+
+export { client, MODEL };
+

services/ragService.js

@@ -0,0 +1,108 @@
+import { generateResponse } from './llmClient.js';
+import { vectorService } from './vectorService.js';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+class RAGService {
+  constructor() {
+    this.vectorService = vectorService;
+  }
+  
+  async retrievePatientContext(patientId, query, nResults = 5) {
+    const patientResults = await this.vectorService.searchPatientRecords(
+      query,
+      patientId,
+      nResults
+    );
+    return { patient_records: patientResults };
+  }
+  
+  async retrieveResearchContext(query, nResults = 3) {
+    return await this.vectorService.searchResearchPapers(query, nResults);
+  }
+  
+  formatContextForLLM(patientContext, researchContext) {
+    const contextParts = [];
+    
+    contextParts.push('=== PATIENT MEDICAL RECORDS ===');
+    if (patientContext.patient_records && patientContext.patient_records.length > 0) {
+      patientContext.patient_records.forEach((record, idx) => {
+        contextParts.push(`\n${idx + 1}. ${record.document}`);
+        contextParts.push(`   Type: ${record.metadata.type || 'unknown'}`);
+      });
+    } else {
+      contextParts.push('No patient records found.');
+    }
+    
+    contextParts.push('\n\n=== RELEVANT MEDICAL RESEARCH ===');
+    if (researchContext && researchContext.length > 0) {
+      researchContext.forEach((paper, idx) => {
+        contextParts.push(`\n${idx + 1}. Title: ${paper.metadata.title || 'Unknown'}`);
+        contextParts.push(`   Content: ${paper.document}`);
+      });
+    } else {
+      contextParts.push('No relevant research found.');
+    }
+    
+    return contextParts.join('\n');
+  }
+  
+  async generateRAGResponse(patientId, patientData, query) {
+    const patientContext = await this.retrievePatientContext(patientId, query, 5);
+    const researchContext = await this.retrieveResearchContext(query, 3);
+    const formattedContext = this.formatContextForLLM(patientContext, researchContext);
+    
+    const prompt = `
+You are an expert medical AI assistant.
+
+PATIENT:
+- Name: ${patientData.name}
+- Age: ${patientData.age}
+- Gender: ${patientData.gender}
+
+CONTEXT:
+${formattedContext}
+
+DOCTOR'S QUESTION:
+${query}
+
+Please give a medically accurate, evidence-based answer.
+`;
+    
+    try {
+      const text = await generateResponse(prompt);
+      
+      return {
+        text,
+        patient_records_used: (patientContext.patient_records || []).length,
+        research_papers_used: researchContext.length,
+        sources: {
+          patient_records: (patientContext.patient_records || []).map(r => ({
+            type: r.metadata.type,
+            content: r.document.substring(0, 200) + '...'
+          })),
+          research_papers: researchContext.map(r => ({
+            title: r.metadata.title,
+            excerpt: r.document.substring(0, 200) + '...'
+          }))
+        }
+      };
+    } catch (error) {
+      return { text: `Error generating AI response: ${error.message}`, error: true };
+    }
+  }
+  
+  async suggestTreatments(patientId, patientData, condition) {
+    const query = `Treatment options for ${condition}`;
+    return await this.generateRAGResponse(patientId, patientData, query);
+  }
+  
+  async analyzeDrugInteractions(patientId, patientData, newMedication) {
+    const currentMeds = (patientData.medications || []).map(m => m.name).join(', ');
+    const query = `Drug interactions between ${newMedication} and current medications: ${currentMeds}`;
+    return await this.generateRAGResponse(patientId, patientData, query);
+  }
+}
+
+export const ragService = new RAGService();

services/timelineService.js

@@ -0,0 +1,286 @@
+import { generateResponse } from './llmClient.js';
+import { ObjectId, getPatientsCollection, getAppointmentsCollection, getWarningsCollection } from '../db/mongo.js';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+class TimelineService {
+  /**
+   * Try to parse a date string in various formats
+   */
+  _parseDate(dateStr) {
+    if (!dateStr) return null;
+    
+    const formats = [
+      // ISO format
+      /^(\d{4})-(\d{2})-(\d{2})$/,
+      // DD/MM/YYYY
+      /^(\d{2})\/(\d{2})\/(\d{4})$/,
+      // MM/DD/YYYY
+      /^(\d{2})\/(\d{2})\/(\d{4})$/,
+    ];
+    
+    // Try direct Date parsing first
+    const date = new Date(dateStr);
+    if (!isNaN(date.getTime())) {
+      return date;
+    }
+    
+    return null;
+  }
+  
+  /**
+   * Create a timeline event
+   */
+  _createEvent(eventType, title, description, date = null, dateStr = '', metadata = {}) {
+    return {
+      type: eventType,
+      title,
+      description,
+      date: date ? date.toISOString() : null,
+      date_display: dateStr || (date ? date.toLocaleDateString('en-US', { 
+        year: 'numeric', 
+        month: 'long', 
+        day: 'numeric' 
+      }) : 'Unknown date'),
+      metadata: metadata || {},
+      sort_date: date ? date.getTime() : 0
+    };
+  }
+  
+  /**
+   * Generate a chronological timeline of all patient events
+   */
+  async getPatientTimeline(patientId) {
+    const patientsCollection = getPatientsCollection();
+    const appointmentsCollection = getAppointmentsCollection();
+    const warningsCollection = getWarningsCollection();
+    
+    const patient = await patientsCollection.findOne({ _id: new ObjectId(patientId) });
+    if (!patient) {
+      return [];
+    }
+    
+    const events = [];
+    
+    // Process medical history
+    const medicalHistory = patient.medical_history || [];
+    for (const item of medicalHistory) {
+      if (typeof item === 'object' && item !== null) {
+        // Structured MedicalEvent
+        const date = this._parseDate(item.date_diagnosed);
+        events.push(this._createEvent(
+          'condition',
+          `Diagnosed: ${item.condition || 'Unknown'}`,
+          item.notes || '',
+          date,
+          item.date_diagnosed || '',
+          {
+            severity: item.severity,
+            resolved: item.date_resolved
+          }
+        ));
+        
+        // Add resolution event if exists
+        if (item.date_resolved) {
+          const resolvedDate = this._parseDate(item.date_resolved);
+          events.push(this._createEvent(
+            'condition_resolved',
+            `Resolved: ${item.condition || 'Unknown'}`,
+            'Condition resolved',
+            resolvedDate,
+            item.date_resolved || '',
+            { original_condition: item.condition }
+          ));
+        }
+      } else {
+        // Legacy string format
+        events.push(this._createEvent(
+          'condition',
+          `Medical History: ${item}`,
+          item,
+          null,
+          '',
+          { legacy_format: true }
+        ));
+      }
+    }
+    
+    // Process medications
+    const medications = patient.medications || [];
+    for (const med of medications) {
+      if (typeof med === 'object' && med !== null) {
+        const startDate = this._parseDate(med.start_date);
+        events.push(this._createEvent(
+          'medication_start',
+          `Started: ${med.name || 'Unknown Medication'}`,
+          `Dosage: ${med.dosage || 'N/A'}`,
+          startDate,
+          med.start_date || '',
+          {
+            medication_name: med.name,
+            dosage: med.dosage
+          }
+        ));
+        
+        // Add end event if medication was stopped
+        if (med.end_date) {
+          const endDate = this._parseDate(med.end_date);
+          events.push(this._createEvent(
+            'medication_end',
+            `Stopped: ${med.name || 'Unknown Medication'}`,
+            'Medication course completed',
+            endDate,
+            med.end_date || '',
+            { medication_name: med.name }
+          ));
+        }
+      }
+    }
+    
+    // Process appointments
+    try {
+      const appointments = await appointmentsCollection.find({ patient_id: patientId }).toArray();
+      for (const apt of appointments) {
+        let aptDate = apt.date_time;
+        if (typeof aptDate === 'string') {
+          aptDate = this._parseDate(aptDate);
+        }
+        events.push(this._createEvent(
+          'appointment',
+          `Appointment: ${apt.purpose || 'Check-up'}`,
+          apt.notes || '',
+          aptDate instanceof Date ? aptDate : null,
+          '',
+          {
+            status: apt.status,
+            doctor_id: apt.doctor_id
+          }
+        ));
+      }
+    } catch (error) {
+      // Appointments collection might not have data yet
+    }
+    
+    // Process warnings (only acknowledged ones for history)
+    try {
+      const warnings = await warningsCollection.find({
+        patient_id: patientId,
+        is_acknowledged: true
+      }).toArray();
+      
+      for (const warning of warnings) {
+        const createdAt = warning.created_at;
+        events.push(this._createEvent(
+          'warning',
+          `Warning: ${warning.title || 'Clinical Warning'}`,
+          warning.description || '',
+          createdAt instanceof Date ? createdAt : null,
+          '',
+          {
+            severity: warning.severity,
+            warning_type: warning.warning_type
+          }
+        ));
+      }
+    } catch (error) {
+      // Warnings collection might not have data yet
+    }
+    
+    // Sort events by date (most recent first), unknown dates at the end
+    events.sort((a, b) => b.sort_date - a.sort_date);
+    
+    // Remove sort_date from output
+    return events.map(event => {
+      const { sort_date, ...rest } = event;
+      return rest;
+    });
+  }
+  
+  /**
+   * Generate an AI-powered summary of the patient's medical timeline
+   */
+  async generateTimelineSummary(patientId) {
+    const patientsCollection = getPatientsCollection();
+    const patient = await patientsCollection.findOne({ _id: new ObjectId(patientId) });
+    
+    if (!patient) {
+      return { error: 'Patient not found' };
+    }
+    
+    const timeline = await this.getPatientTimeline(patientId);
+    
+    // Format timeline for AI
+    const timelineText = timeline.slice(0, 20).map(event => 
+      `- ${event.date_display}: ${event.title} - ${event.description}`
+    ).join('\n');
+    
+    const prompt = `You are a medical AI assistant. Analyze this patient's medical timeline and provide a comprehensive summary.
+
+PATIENT: ${patient.name || 'Unknown'}
+Age: ${patient.age || 'Unknown'}
+Gender: ${patient.gender || 'Unknown'}
+
+MEDICAL TIMELINE:
+${timelineText || 'No timeline events available.'}
+
+Please provide:
+1. **Overview**: A brief summary of the patient's medical journey
+2. **Key Milestones**: The most significant medical events
+3. **Patterns**: Any notable patterns in conditions or treatments
+4. **Current Status**: Assessment of current health based on timeline
+5. **Recommendations**: Suggested follow-ups or areas of attention
+
+Be concise but thorough. Use bullet points where appropriate.`;
+
+    try {
+      const summary = await generateResponse(prompt);
+      
+      return {
+        patient_id: patientId,
+        patient_name: patient.name,
+        summary,
+        events_analyzed: timeline.length,
+        generated_at: new Date().toISOString()
+      };
+    } catch (error) {
+      return { error: `Error generating summary: ${error.message}` };
+    }
+  }
+  
+  /**
+   * Get statistics about the patient's timeline
+   */
+  async getTimelineStats(patientId) {
+    const timeline = await this.getPatientTimeline(patientId);
+    
+    const stats = {
+      total_events: timeline.length,
+      by_type: {},
+      date_range: {
+        earliest: null,
+        latest: null
+      }
+    };
+    
+    const dates = [];
+    for (const event of timeline) {
+      const eventType = event.type;
+      stats.by_type[eventType] = (stats.by_type[eventType] || 0) + 1;
+      if (event.date) {
+        dates.push(event.date);
+      }
+    }
+    
+    if (dates.length > 0) {
+      dates.sort();
+      stats.date_range.earliest = dates[0];
+      stats.date_range.latest = dates[dates.length - 1];
+    }
+    
+    return stats;
+  }
+}
+
+// Singleton instance
+export const timelineService = new TimelineService();

services/vectorService.js

@@ -0,0 +1,261 @@
+import { ChromaClient } from 'chromadb';
+
+class VectorService {
+  constructor() {
+    this.chromaClient = null;
+    this.patientCollection = null;
+    this.researchCollection = null;
+    this.initialized = false;
+  }
+  
+  async initialize() {
+    if (this.initialized) return;
+    
+    try {
+      this.chromaClient = new ChromaClient({
+        path: './chroma_db'
+      });
+      
+      this.patientCollection = await this._getOrCreateCollection('patient_records');
+      this.researchCollection = await this._getOrCreateCollection('medical_research');
+      this.initialized = true;
+      console.log('✓ Vector database initialized');
+    } catch (error) {
+      console.log(`⚠️ Vector database initialization warning: ${error.message}`);
+    }
+  }
+  
+  async _getOrCreateCollection(name) {
+    try {
+      return await this.chromaClient.getCollection({ name });
+    } catch {
+      return await this.chromaClient.createCollection({
+        name,
+        metadata: { description: `Collection for ${name}` }
+      });
+    }
+  }
+  
+  async addPatientRecord(patientId, patientData) {
+    await this.initialize();
+    
+    const documents = [];
+    const metadatas = [];
+    const ids = [];
+    
+    // Add medical history
+    if (patientData.medical_history) {
+      patientData.medical_history.forEach((condition, idx) => {
+        const docId = `patient_${patientId}_history_${idx}`;
+        const conditionText = typeof condition === 'string' ? condition : condition.condition || 'Unknown';
+        documents.push(`Patient ${patientData.name} has medical history: ${conditionText}`);
+        metadatas.push({
+          patient_id: patientId,
+          patient_name: patientData.name,
+          type: 'medical_history',
+          condition: conditionText,
+          age: String(patientData.age || ''),
+          gender: patientData.gender || ''
+        });
+        ids.push(docId);
+      });
+    }
+    
+    // Add medications
+    if (patientData.medications) {
+      patientData.medications.forEach((med, idx) => {
+        const docId = `patient_${patientId}_medication_${idx}`;
+        let medText = `Patient ${patientData.name} is taking ${med.name}, dosage: ${med.dosage}, started: ${med.start_date}`;
+        if (med.end_date) {
+          medText += `, ended: ${med.end_date}`;
+        }
+        documents.push(medText);
+        metadatas.push({
+          patient_id: patientId,
+          patient_name: patientData.name,
+          type: 'medication',
+          medication_name: med.name,
+          dosage: med.dosage,
+          start_date: med.start_date
+        });
+        ids.push(docId);
+      });
+    }
+    
+    // Add summary
+    const medHistory = patientData.medical_history || ['None'];
+    const medNames = (patientData.medications || []).map(m => m.name);
+    const summaryText = `
+      Patient Profile: ${patientData.name}, Age: ${patientData.age}, Gender: ${patientData.gender}.
+      Medical History: ${medHistory.join(', ')}.
+      Current Medications: ${medNames.join(', ') || 'None'}.
+    `.trim();
+    
+    documents.push(summaryText);
+    metadatas.push({
+      patient_id: patientId,
+      patient_name: patientData.name,
+      type: 'summary',
+      age: String(patientData.age || ''),
+      gender: patientData.gender || ''
+    });
+    ids.push(`patient_${patientId}_summary`);
+    
+    if (documents.length > 0) {
+      try {
+        await this.patientCollection.upsert({
+          documents,
+          metadatas,
+          ids
+        });
+        console.log(`   ✓ Indexed ${documents.length} records for patient ${patientData.name}`);
+      } catch (error) {
+        console.log(`   ✗ Error indexing patient ${patientData.name}: ${error.message}`);
+      }
+    }
+    
+    return documents.length;
+  }
+  
+  async searchPatientRecords(query, patientId = null, nResults = 5) {
+    await this.initialize();
+    
+    try {
+      const whereFilter = patientId ? { patient_id: patientId } : undefined;
+      
+      const results = await this.patientCollection.query({
+        queryTexts: [query],
+        nResults,
+        where: whereFilter
+      });
+      
+      const formattedResults = [];
+      if (results && results.documents && results.documents[0]) {
+        for (let idx = 0; idx < results.documents[0].length; idx++) {
+          formattedResults.push({
+            document: results.documents[0][idx],
+            metadata: results.metadatas[0][idx],
+            distance: results.distances ? results.distances[0][idx] : null
+          });
+        }
+      }
+      
+      return formattedResults;
+    } catch (error) {
+      console.log(`Search error: ${error.message}`);
+      return [];
+    }
+  }
+  
+  async addResearchPaper(paperId, title, content, metadata) {
+    await this.initialize();
+    
+    try {
+      const chunkSize = 1000;
+      const chunks = [];
+      const words = content.split(' ');
+      
+      for (let i = 0; i < words.length; i += chunkSize) {
+        const chunk = words.slice(i, i + chunkSize).join(' ');
+        chunks.push(chunk);
+      }
+      
+      const documents = [];
+      const metadatas = [];
+      const ids = [];
+      
+      chunks.forEach((chunk, idx) => {
+        documents.push(chunk);
+        const chunkMetadata = {
+          paper_id: paperId,
+          title,
+          chunk_index: String(idx),
+          total_chunks: String(chunks.length),
+          ...Object.fromEntries(Object.entries(metadata).map(([k, v]) => [k, String(v)]))
+        };
+        metadatas.push(chunkMetadata);
+        ids.push(`research_${paperId}_chunk_${idx}`);
+      });
+      
+      if (documents.length > 0) {
+        await this.researchCollection.upsert({
+          documents,
+          metadatas,
+          ids
+        });
+      }
+      
+      return chunks.length;
+    } catch (error) {
+      console.log(`Error adding research paper: ${error.message}`);
+      return 0;
+    }
+  }
+  
+  async searchResearchPapers(query, nResults = 5) {
+    await this.initialize();
+    
+    try {
+      const results = await this.researchCollection.query({
+        queryTexts: [query],
+        nResults
+      });
+      
+      const formattedResults = [];
+      if (results && results.documents && results.documents[0]) {
+        for (let idx = 0; idx < results.documents[0].length; idx++) {
+          formattedResults.push({
+            document: results.documents[0][idx],
+            metadata: results.metadatas[0][idx],
+            distance: results.distances ? results.distances[0][idx] : null
+          });
+        }
+      }
+      
+      return formattedResults;
+    } catch (error) {
+      console.log(`Research search error: ${error.message}`);
+      return [];
+    }
+  }
+  
+  async deletePatientRecords(patientId) {
+    await this.initialize();
+    
+    try {
+      const results = await this.patientCollection.get({
+        where: { patient_id: patientId }
+      });
+      
+      if (results && results.ids && results.ids.length > 0) {
+        await this.patientCollection.delete({ ids: results.ids });
+      }
+      return true;
+    } catch (error) {
+      console.log(`Error deleting patient records: ${error.message}`);
+      return false;
+    }
+  }
+  
+  async getCollectionStats() {
+    await this.initialize();
+    
+    try {
+      const patientCount = await this.patientCollection.count();
+      const researchCount = await this.researchCollection.count();
+      
+      return {
+        patient_records_count: patientCount,
+        research_papers_count: researchCount
+      };
+    } catch {
+      return {
+        patient_records_count: 0,
+        research_papers_count: 0
+      };
+    }
+  }
+}
+
+export const vectorService = new VectorService();
+

services/warningService.js

@@ -0,0 +1,293 @@
+import { generateResponse } from './llmClient.js';
+import { ObjectId, getWarningsCollection, getPatientsCollection } from '../db/mongo.js';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+// Warning types enum
+export const WarningType = {
+  DRUG_INTERACTION: 'drug_interaction',
+  ALLERGY: 'allergy',
+  CONTRAINDICATION: 'contraindication',
+  ABNORMAL_PATTERN: 'abnormal_pattern',
+  DOSAGE_ALERT: 'dosage_alert',
+  DUPLICATE_THERAPY: 'duplicate_therapy'
+};
+
+// Warning severity enum
+export const WarningSeverity = {
+  LOW: 'low',
+  MEDIUM: 'medium',
+  HIGH: 'high',
+  CRITICAL: 'critical'
+};
+
+class WarningService {
+  /**
+   * Convert MongoDB warning document to response format
+   */
+  _warningHelper(warning) {
+    return {
+      id: warning._id.toString(),
+      patient_id: warning.patient_id,
+      warning_type: warning.warning_type,
+      severity: warning.severity,
+      title: warning.title,
+      description: warning.description,
+      related_medications: warning.related_medications || [],
+      related_conditions: warning.related_conditions || [],
+      recommendation: warning.recommendation || null,
+      created_at: warning.created_at,
+      is_acknowledged: warning.is_acknowledged || false,
+      acknowledged_by: warning.acknowledged_by || null,
+      acknowledged_at: warning.acknowledged_at || null
+    };
+  }
+  
+  /**
+   * Get all warnings for a patient
+   */
+  async getPatientWarnings(patientId, includeAcknowledged = false) {
+    const warningsCollection = getWarningsCollection();
+    const query = { patient_id: patientId };
+    
+    if (!includeAcknowledged) {
+      query.is_acknowledged = false;
+    }
+    
+    const warnings = await warningsCollection
+      .find(query)
+      .sort({ created_at: -1 })
+      .toArray();
+    
+    return warnings.map(w => this._warningHelper(w));
+  }
+  
+  /**
+   * Get all unacknowledged warnings across all patients
+   */
+  async getAllUnacknowledgedWarnings(limit = 50) {
+    const warningsCollection = getWarningsCollection();
+    
+    const warnings = await warningsCollection
+      .find({ is_acknowledged: false })
+      .sort({ severity: -1, created_at: -1 })
+      .limit(limit)
+      .toArray();
+    
+    return warnings.map(w => this._warningHelper(w));
+  }
+  
+  /**
+   * Acknowledge a clinical warning
+   */
+  async acknowledgeWarning(warningId, userId, notes = null) {
+    const warningsCollection = getWarningsCollection();
+    
+    const result = await warningsCollection.updateOne(
+      { _id: new ObjectId(warningId) },
+      {
+        $set: {
+          is_acknowledged: true,
+          acknowledged_by: userId,
+          acknowledged_at: new Date(),
+          acknowledgement_notes: notes
+        }
+      }
+    );
+    
+    if (result.matchedCount === 0) {
+      return null;
+    }
+    
+    const warning = await warningsCollection.findOne({ _id: new ObjectId(warningId) });
+    return this._warningHelper(warning);
+  }
+  
+  /**
+   * Create a new clinical warning
+   */
+  async createWarning(warningData) {
+    const warningsCollection = getWarningsCollection();
+    
+    const warningDoc = {
+      ...warningData,
+      created_at: new Date(),
+      is_acknowledged: false
+    };
+    
+    const result = await warningsCollection.insertOne(warningDoc);
+    warningDoc._id = result.insertedId;
+    return this._warningHelper(warningDoc);
+  }
+  
+  /**
+   * Delete all warnings for a patient
+   */
+  async deletePatientWarnings(patientId) {
+    const warningsCollection = getWarningsCollection();
+    const result = await warningsCollection.deleteMany({ patient_id: patientId });
+    return result.deletedCount;
+  }
+  
+  /**
+   * Use AI to analyze patient data and generate clinical warnings
+   */
+  async analyzePatientForWarnings(patientId, newMedication = null, newCondition = null) {
+    const patientsCollection = getPatientsCollection();
+    const patient = await patientsCollection.findOne({ _id: new ObjectId(patientId) });
+    
+    if (!patient) {
+      return [];
+    }
+    
+    // Build the analysis prompt
+    const medications = patient.medications || [];
+    const medNames = medications
+      .filter(m => typeof m === 'object')
+      .map(m => m.name || '');
+    
+    let conditions = patient.medical_history || [];
+    
+    if (newMedication) {
+      medNames.push(`${newMedication} (NEW)`);
+    }
+    if (newCondition) {
+      conditions = [...conditions, `${newCondition} (NEW)`];
+    }
+    
+    const conditionsText = conditions.map(c => {
+      if (typeof c === 'string') return c;
+      return c.condition || 'Unknown';
+    }).join(', ');
+    
+    const prompt = `You are a clinical decision support AI. Analyze this patient's data for potential clinical warnings.
+
+PATIENT INFORMATION:
+- Age: ${patient.age || 'Unknown'}
+- Gender: ${patient.gender || 'Unknown'}
+- Medical Conditions: ${conditionsText || 'None recorded'}
+- Current Medications: ${medNames.join(', ') || 'None recorded'}
+
+Analyze for:
+1. DRUG INTERACTIONS - Check if any medications interact negatively with each other
+2. CONTRAINDICATIONS - Check if any medications are contraindicated given the patient's conditions
+3. ALLERGY RISKS - Common allergy cross-reactions
+4. DOSAGE CONCERNS - Age-related dosage considerations
+5. DUPLICATE THERAPY - Multiple drugs for the same purpose
+
+Return a JSON array of warnings. Each warning should have:
+- warning_type: one of "drug_interaction", "allergy", "contraindication", "abnormal_pattern", "dosage_alert", "duplicate_therapy"
+- severity: one of "low", "medium", "high", "critical"
+- title: short title (max 50 chars)
+- description: detailed explanation
+- related_medications: array of medication names involved
+- related_conditions: array of conditions involved
+- recommendation: suggested action
+
+If there are no warnings, return an empty array [].
+Return ONLY valid JSON, no markdown or other text.`;
+
+    try {
+      let responseText = await generateResponse(prompt);
+      responseText = responseText.trim();
+      
+      // Remove markdown code blocks if present
+      if (responseText.startsWith('```')) {
+        responseText = responseText.split('```')[1];
+        if (responseText.startsWith('json')) {
+          responseText = responseText.substring(4);
+        }
+      }
+      responseText = responseText.trim();
+      
+      const warningsData = JSON.parse(responseText);
+      
+      if (!Array.isArray(warningsData)) {
+        return [];
+      }
+      
+      // Create warnings in database
+      const createdWarnings = [];
+      for (const warning of warningsData) {
+        try {
+          const warningCreate = {
+            patient_id: patientId,
+            warning_type: warning.warning_type || 'abnormal_pattern',
+            severity: warning.severity || 'medium',
+            title: (warning.title || 'Clinical Warning').substring(0, 100),
+            description: warning.description || '',
+            related_medications: warning.related_medications || [],
+            related_conditions: warning.related_conditions || [],
+            recommendation: warning.recommendation || null
+          };
+          
+          const createdWarning = await this.createWarning(warningCreate);
+          createdWarnings.push(createdWarning);
+        } catch (error) {
+          console.log(`Error creating warning: ${error.message}`);
+          continue;
+        }
+      }
+      
+      return createdWarnings;
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        console.log(`JSON parse error: ${error.message}`);
+      } else {
+        console.log(`Error analyzing patient: ${error.message}`);
+      }
+      return [];
+    }
+  }
+  
+  /**
+   * Get warning statistics
+   */
+  async getWarningStats() {
+    const warningsCollection = getWarningsCollection();
+    
+    const pipeline = [
+      {
+        $group: {
+          _id: {
+            severity: '$severity',
+            acknowledged: '$is_acknowledged'
+          },
+          count: { $sum: 1 }
+        }
+      }
+    ];
+    
+    const results = await warningsCollection.aggregate(pipeline).toArray();
+    
+    const stats = {
+      total: 0,
+      unacknowledged: 0,
+      by_severity: {
+        critical: 0,
+        high: 0,
+        medium: 0,
+        low: 0
+      }
+    };
+    
+    for (const r of results) {
+      const count = r.count;
+      stats.total += count;
+      
+      if (!r._id.acknowledged) {
+        stats.unacknowledged += count;
+        const severity = r._id.severity;
+        if (severity in stats.by_severity) {
+          stats.by_severity[severity] += count;
+        }
+      }
+    }
+    
+    return stats;
+  }
+}
+
+// Singleton instance
+export const warningService = new WarningService();