ajaymehta097/kishanai

1. Repository shape

- This is a split-stack agricultural advisor app: a React/Vite frontend in src/ and an Express backend in server/.

- The frontend is the user-facing product; the backend owns most domain logic, data access, ML inference, and calls to external APIs.

2. Frontend shell and composition

- src/App.jsx, src/main.jsx, and the layout/components folders define the UI shell, page composition, and shared design system.

- src/pages/ maps the main user journeys: crop recommendation, disease detection, fertilizer guidance, satellite view, chat, weather/irrigation/profit/market, and auth.

3. Frontend state and cross-cutting services

- src/context/AppContext.jsx and src/context/AuthContext.jsx centralize app-wide state and login state.

- src/hooks/useLocation.js and src/utils/geoUtils.js determine the user’s location/state, which is then reused across features.

- src/hooks/useVoice.js adds browser speech input, supporting voice-driven interaction.

4. Frontend API boundary

- src/api/agriBackend.js is the main client gateway to the backend.

- src/api/config.js is the feature switchboard: it chooses the backend base URL and toggles whether a feature uses the real backend or Claude AI fallback.

- vite.config.js proxies /api/* to the backend during local development.

5. Location as a shared input

- The app captures GPS once, maps it to a state name, and stores it in session storage.

- That location is sent to backend calls through query params, request bodies, and x-latitude / x-longitude / x-state headers.

- server/middleware/location.middleware.js normalizes this input so controllers can consume location consistently.

6. Backend HTTP layer

- server/server.js and server/app.js define the Express app, middleware chain, and route mounting.

- server/routes/*.routes.js split the API by domain: auth, chatbot, crop, disease, fertilizer, irrigation, location, market, profit, satellite, and weather.

- Controllers in server/controllers/ implement the request/response logic for each domain.

7. Backend service layer

- server/services/ contains the external-integration and orchestration layer.

- Notable services include weather.service.js, market.service.js, location.service.js, chatbot.service.js, and bhashini.service.js.

- This is where API aggregation and AI/service calls are isolated from controllers.

8. Core domain flows

- Crop recommendation uses soil inputs plus live weather to rank candidate crops.

- Disease detection accepts an uploaded image and returns disease/treatment guidance.

- Fertilizer, irrigation, and profit endpoints provide agronomy calculators and advice.

- Weather and market are location-aware: weather enriches farming recommendations, and market prices are filtered by the user’s state.

9. Data storage and models

- MongoDB is the primary persistent store, configured through server/config/db.js.

- server/models/user.js and server/models/Market.js are the main database models.

- server/uploads/ supports file handling for image-based workflows such as disease detection.

10. ML and AI boundaries

- The backend ships a local disease model in server/models/model.h5 with labels in server/models/labels.txt, so disease inference is not purely external.

- The frontend also supports a Claude-based fallback in src/api/claude.js; the README notes this is used especially for the vegetable planner and any feature disabled in USE_BACKEND.

- The chatbot path combines backend orchestration with Hugging Face and Bhashini for multilingual/STT/TTS behavior.

11. Security and request shaping

- server/middleware/auth.middleware.js protects authenticated routes.

- server/middleware/error.middleware.js centralizes API error handling.

- server/utils/responseHandler.js suggests a standardized response envelope across endpoints.

12. Deployment/runtime boundaries

- Local development is a two-process setup: React/Vite on the frontend and Express on port 5000 for the backend.

- capacitor.config.json indicates the frontend is also intended for mobile packaging.

- vercel.json suggests a web deployment path for the frontend, while the backend depends on environment variables for MongoDB and third-party API keys.

13. Architecture summary for a diagram

- Draw the frontend as a presentation/orchestration layer that gathers user input, location, and voice.

- Draw the backend as a domain API layer with route → controller → service → data/external API paths.

- Show MongoDB, the local ML model, and external services (OpenWeatherMap, Hugging Face, Bhashini, Claude) as separate dependencies behind the backend.