akshatsinghnayal/sih-project-2025

1. Repository shape

- This is a two-part monorepo: a React/TypeScript frontend in SIH-Chat-Bot/ and an optional Node/Express backend in server/.

- The frontend can talk to Gemini directly in dev mode, or route through the backend for production-style streaming.

2. Primary product boundary

- The app is a student mental-wellness chatbot: anonymous chat, supportive AI responses, and no heavy user profile system.

- The architecture is intentionally simple around a single core loop: user message in, Gemini response out, with optional persistence.

3. Frontend application shell

- SIH-Chat-Bot/App.tsx, index.tsx, and index.html form the app entry path.

- App.tsx likely decides between authentication and chat experience, while global styling is handled by index.css plus Tailwind CDN usage noted in the README.

- vite.config.ts and tsconfig.json indicate a Vite-built SPA.

4. UI composition

- The chat UI is split into focused components:

- components/Auth.tsx for login/signup

- components/ChatView.tsx for the main conversation area

- components/ChatWindow.tsx for message rendering and input handling

- components/Sidebar.tsx for session/history/navigation controls

- components/icons/ holds local SVG-style UI assets, suggesting the app avoids a separate icon library.

5. State and auth boundary

- context/AuthContext.tsx and hooks/useAuth.ts define the app’s auth layer.

- The README says auth is mocked with localStorage, so authentication is a client-side state boundary rather than a real identity service.

- This makes auth lightweight and keeps the mental-wellness experience anonymous.

6. Chat data flow in the frontend

- The chat experience is centered on stateful UI components feeding message data through service calls and rendering responses back into the conversation pane.

- types.ts and constants.ts likely define shared message/session shapes and prompt/UI constants, keeping chat logic consistent across components.

7. AI integration layer

- services/geminiService.ts is the direct integration point for Google Gemini.

- services/apiService.ts likely abstracts whether requests go to the local Gemini client path or the backend API, based on environment flags such as VITE_USE_REMOTE_API.

- This creates a clean split between UI logic and model-provider communication.

8. Streaming response architecture

- The README highlights Server-Sent Events (SSE) and real-time streaming.

- In browser-only mode, streaming may be handled directly from the client SDK; in backend mode, the Express server acts as the streaming relay so the frontend can progressively render token/character updates.

- This is the key interactive boundary in the system: input is immediate, output is incremental.

9. Backend responsibilities

- server/index.js is the Express entry point, with server/db.js for MongoDB connection and server/models.js for persistence schemas.

- The backend is described as optional, so it is not the single source of truth for the product; it mainly supports production-safe streaming and optional chat persistence.

- server/.env.example suggests the backend is configured around GEMINI_API_KEY and optionally MONGODB_URI.

10. Persistence layer

- MongoDB is explicitly optional, which means chat history storage is not required for core operation.

- If enabled, the data boundary sits entirely in the backend via Mongoose models, keeping the frontend anonymous and lightweight.

11. Deployment/runtime boundaries

- render.yaml and DEPLOY-RENDER.md indicate the project is designed for deployment on Render.

- SIH-Chat-Bot/public/_redirects suggests SPA routing support for static hosting.

- The repo therefore supports two runtime topologies: static frontend only, or frontend plus backend API service.

12. Implementation themes that matter architecturally

- The app is built to be privacy-preserving, responsive, and emotionally safe rather than feature-heavy.

- Markdown rendering and the calming UI are presentation concerns; the meaningful architectural concerns are the split between client/UI, Gemini integration, streaming transport, and optional persistence.