I built this as a working prototype for an enterprise-style IT helpdesk experience: employees can submit IT issues, ask support questions, receive AI-guided troubleshooting, and have work routed through an intelligent automation flow resembling a ServiceNow-style helpdesk.
My repository dates are started 2026-10; last updated 2026-10.
My project objective is to classify natural-language employee requests, retrieve approved troubleshooting knowledge, decide whether a request can be self-healed, and track it like a real IT service desk ticket.
My five demo scenarios are Intelligent Ticket Intake; Auto Resolution / Self-Heal Agent; Knowledge Management Automation; Self-Service Portal & Chatbot; Software Provisioning Automation.
My architecture comprises a React frontend; FastAPI backend; vector-search knowledge base with grounded retrieval; mock ticketing and automation flows; operational dashboard.
My frontend includes Chat panel; Dashboard; Knowledge Base page; Requests page; Ticket creation flow; enterprise-styled dashboard cards and request tables; frontend/src/App.jsx, frontend/src/styles.css, frontend/src/main.jsx.
My backend shell provides app initialization, CORS configuration, health endpoints, versioned API routing, MongoDB preparation at startup; backend/app/main.py, backend/app/routers/health.py, backend/app/routers/knowledge.py.
My knowledge retrieval uses approved IT documents; embedding generation; Chroma-backed vector search; source-aware metadata including title, category, topic, and file; semantic lookup; knowledge_pipeline.py, knowledge_vector_store.py, knowledge_chunks.jsonl, and Chroma persistence.
My assistant searches approved support content, builds natural-language responses, presents troubleshooting steps, and avoids exposing internal workflow text in visible chat.
My grounded chat assistant is implemented in backend/app/chat_assistant.py.
My ticket and dashboard workflow provides ticket intake with AI classification and incident creation; dashboard filters open and resolved tickets and shows ticket details, confidence, routing, suggested resolution, and knowledge sources.
My ticket records are kept in memory when MongoDB is unavailable and also written to MongoDB when the connection is available.
My MongoDB foundation provides settings, client creation, collection preparation, and collection naming for tickets, knowledge, chat, audit, and software requests in backend/app/database.py.
My shared schemas cover AI orchestration inputs and outputs; support request metadata; ticket and incident style records; knowledge search results; automation-related payloads.
My shared data contracts are implemented in backend/app/schemas.py.
My automated checks cover backend app shell startup; knowledge retrieval behavior; knowledge pipeline integration; foundation-level app functionality.
My demo flow is to ask a support question or create a ticket; retrieve against approved docs; craft a grounded answer; view a knowledge result or ask live chat; see simulated active requests and ticket history.
My technology stack is React + Vite; FastAPI + Python; sentence-transformers + Chroma; MongoDB-ready / PyMongo integration; Pydantic; Python unittest.
My project layout includes backend/app/, backend/requirements.txt, frontend/, data/knowledge_docs/, data/embeddings/, data/vector_store/chroma/, docs/, tests/, plan.md, workflow.md, README.md.
My prerequisites are Node.js 18+; Python 3.10+; working backend virtual environment; optional MongoDB local instance or Atlas connection for persistence.
My install and frontend commands are cd frontend; npm install; cd backend; pip install -r requirements.txt; cd frontend; npm run dev.
My documented backend run is cd /media/hp/New Volume1/AI_HACKATHON_FRESHER; source /home/hp/.venvs/default/bin/activate; Uvicorn on port 8000.
My fast start is Linux Bash; /media/hp/New Volume/AI_HACKATHON_FRESHER; .venv/bin/activate; MONGODB_DB=itsm_ai; Uvicorn --reload on port 8000; npm run frontend:dev.
My app URLs are http://<redacted>:8000/docs; http://<redacted>:8000/health; http://<redacted>:8000/api/v1/health.
My knowledge pipeline commands are python -m backend.app.knowledge_pipeline; python -m backend.app.knowledge_vector_store.
My docs/demo_runbook.md contains a Phase 7.4 rehearsal plan with timing, scenario order, fallback strategy, and architecture summary; speaking script for the final hackathon walkthrough.
I treat the system as a hackathon/demo prototype, not a production-ready deployment. The setup notes contain two different project paths and virtual-environment activation paths, and do not identify which is canonical. They provide no quantitative retrieval, accuracy, performance, or ticket-volume results, nor details about production security, scaling, or operational readiness.
I have a strong demo foundation, but the project is not yet complete against the full enterprise brief. My next direction is to turn the prototype into a more complete enterprise workflow through persistence, ticketing, automation, and fuller AI orchestration.
The completed foundation includes React app shell and portal navigation.
The completed foundation includes FastAPI backend shell and health API.
The completed foundation includes knowledge doc collection and vector store and retrieval workflow.
The completed foundation includes chat response generation grounded in approved documentation.
The completed foundation includes ticket intake connected to backend incident creation.
The completed foundation includes backend ticket list and detail endpoints.
The completed foundation includes dashboard filters for open and resolved records, with AI analysis details.
The completed foundation includes a basic automated test suite.
The remaining work includes real MongoDB-backed records, ServiceNow/mock service integration, automation execution workflow and audit trail, software provisioning automation, stronger LLM orchestration, and broader product polish and deployment hardening.
- My persistence scope includes: persist tickets in MongoDB,; save chat history,; store software requests,; save automation audit logs,; support ticket updates and status transitions.
- My ServiceNow integration or matching mock API should: create incident records,; update existing incidents,; open service requests,; return ticket IDs and resolution status,; and mirror a real ServiceNow JSON contract.
- My planned self-heal layer covers password reset / unlock flows,; VPN status checks,; service restarts,; cache clears,; app restarts,; and account lockout troubleshooting.
- For each workflow, the system should assess whether a workflow is safe,; whether it is automatable,; or whether it should escalate to a human agent.
- Every automated-action audit entry should capture time stamp,; task name,; result,; confidence level,; who/what initiated it,; and whether it succeeded or failed.
- My software-provisioning workflow should cover employee requests software,; AI identifies it as a provisioning request,; service request is created,; mock provisioning status is tracked,; and UI shows progress and final state.
- For stronger model capabilities, I plan to evaluate an open-source LLM from Hugging Face or another lightweight model,; intent classification and summarization through the model,; confidence scoring,; and more structured response generation.
- I plan to expand the approved support-document collection to cover software installation,; application access,; endpoint/device management,; employee onboarding/offboarding,; account provisioning,; laptop health checks,; printer troubleshooting,; and multi-factor authentication issues.
- For demo UX and workflow validation, I want clearer chat/ticket separation,; better visual states for in-progress and resolved cases,; ticket detail pages,; richer request history,; and polished presentation for a live demo.
- Production-readiness work includes authentication and authorization,; secure environment variables and secret handling,; restricted CORS settings,; production deployment config,; error monitoring,; and structured logging.
The intended AI direction is to keep responses grounded in approved documentation while adding model-based intent classification, summarization, confidence scoring, and structured response generation. Open implementation questions remain around MongoDB design and deployment, ServiceNow versus a mock contract, safe-automation and escalation criteria, model selection, security and production configuration, and demo acceptance criteria. No schedule, owners, or delivery dates are specified.