I focus on building useful systems and making them faster and more reliable. My recent work includes multi-agent evaluation, real-time communication, legal document intelligence, and geo-spatial governance workflows.
I focus on measurable quality and production readiness.
I build and deploy multi-agent systems and Deep Agents with LangChain and LangGraph across networked machines and local LLM deployments.
I built a 44-case LangSmith evaluation suite.
The evaluation suite raised the pass rate from 14% to 95%.
I cut agent latency by approximately 90%.
I reduced final-output streaming time by approximately 70%.
I describe myself as an AI Engineer building AI-native products, multi-agent systems, and distributed platforms.
I build reliable AI and full-stack systems.
My stated practices include AI-native coding workflows, AI Loop Engineering, Context Engineering, Graph Engineering, LLM Evals, observability, and Harness Engineering practices.
My AI technologies include LangChain, LangGraph, RAG, GraphRAG, and MCP.
I use React, Next.js, Kafka, Redis, Docker, and Kubernetes to ship products.
My product goals are measurable, low-latency products.
I categorize ChannelIQ as a Real-Time Communication Platform.
My ChannelIQ project page is https://codesahil21-dev.vercel.app/projects/channeliq-enterprise-communication-platform.
I categorize VendorClause AI as a Legal Document Intelligence Platform.
My VendorClause AI project page is https://codesahil21-dev.vercel.app/projects/vendorclause-ai-polygot.
I categorize Civic-Issue as a Geo-Spatial Governance Platform.
My Civic-Issue project page is https://codesahil21-dev.vercel.app/projects/vmc-civic-issue-monitoring-system.
My Learnit project page is https://codesahil21-dev.vercel.app/projects/learnit-learning-management-system.
I categorize GoFleet as a Real-Time Ride Platform.
My GoFleet project page is https://codesahil21-dev.vercel.app/projects/gofleet-real-time-ride-platform.
My Portfolio project page is https://codesahil21-dev.vercel.app/projects/portfolio.
I categorize EchoRay as AI-Powered Real-Time Code Collaboration.
My EchoRay project page is https://codesahil21-dev.vercel.app/projects/echoray-ai-code-collaboration.
I showcase seven projects on my portfolio’s Projects section. The page notes that some ideas are still under construction, but does not identify which ones.
I describe ChannelIQ as a comprehensive enterprise communication platform built with microservices, real-time messaging, video conferencing, and professional networking.
I describe VendorClause AI as an end-to-end AI document intelligence platform for legal-style workflows with async ingestion, hybrid retrieval, and streaming source-grounded answers.
I describe Civic-Issue as a geo-fenced, offline-first platform to report, track, and resolve municipal civic issues with speed and accountability.
I describe Learnit as a full-stack LMS for role-based course delivery, progress tracking, and certificate generation.
I describe GoFleet as a full-stack Uber-like platform for real-time ride booking, tracking, and captain operations.
I describe Portfolio as my current portfolio showcasing projects, skills, and full-stack plus AI engineering work.
I describe EchoRay as a modern AI-powered collaboration platform for project management, real-time coding, chat, and instant code assistance.
I use a broad toolkit to turn ideas into dependable systems, spanning AI and LLM engineering, full-stack development, distributed systems, data platforms, and cloud-native infrastructure. I value evaluation, observability, performance, and maintainable delivery as much as the feature itself.
My programming-language tools include Python, TypeScript, JavaScript, SQL.
My frontend and web-development tools include React.js, Next.js, Redux Toolkit, Tailwind CSS, Axios, Node.js, Express, Express.js.
My backend, data, and infrastructure tools include Apache Kafka, Redis, BullMQ, Socket.IO, Prisma, PostgreSQL, MongoDB, MinIO, Docker, K8s, Kubernetes, GitHub Actions.
My AI, LLM, evaluation, and graph-engineering tools and practices include LangGraph, LangChain, AI-Native Coding, AI Loop Engineering, Context Engineering, Graph Engineering, LLM Evals, Harness Engineering, Qdrant, Neo4j, LlamaParse, FastEmbed, Mem0, Langfuse.
I am pursuing a B.Tech in Computer Science with a Cloud Computing specialization at Parul University, Vadodara.
My degree dates are Aug 2023 - 2027 (Expected).
My relevant coursework includes Data Structures and Algorithms, Operating Systems, DBMS, Computer Networks, and Object-Oriented Programming.
I completed Higher Secondary education in the Science stream at Thakur College of Science and Commerce.
I completed secondary schooling at National English School, which gave me a strong foundation in science and mathematics.
I support my academic path through consistent problem-solving practice and hands-on project work in backend systems and AI engineering.
I work as an AI Engineer while pursuing a B.Tech in Computer Science and Engineering at Parul University. My work spans full-stack platform development and AI systems, with an interest in engineering problems where latency, reliability, observability, and clean system boundaries matter.
I am a B.Tech Computer Science and Engineering student at Parul University (2023–2027).
I design and ship production-grade platforms across the full stack, from React/Next.js frontends to event-driven backends with Kafka, Redis, and WebSockets.
On the AI side, I build multi-agent systems.
I build RAG and GraphRAG pipelines and MCP integrations using LangGraph, LangChain, Qdrant, Neo4j, and local LLMs.
I apply AI Loop Engineering, Context Engineering, Graph Engineering, and LLM Evals with LangSmith and Langfuse.
I use Harness Engineering practices to improve reliability and delivery.
I have shipped systems for real-time communication, legal document intelligence, and geo-spatial governance.
I enjoy solving hard engineering problems around latency, reliability, observability, and clean system boundaries.
My ChannelIQ repository is a TypeScript repository on @CodeSahil21’s GitHub; started 2025-08 and last updated in 2026-04.
My ChannelIQ service ports are client 3000, API Gateway 4000, Auth 3001, User Management 3002, Chat 3004, Media 3003, and Meeting 3005.
My ChannelIQ technology stack is React 19 with TypeScript, Redux Toolkit, Socket.IO Client, LiveKit, Framer Motion, Vite, Node.js with TypeScript, Express, Prisma with PostgreSQL, Redis, and Kafka.
My ChannelIQ documented product capabilities include JWT authentication with HTTP-only cookies and OTP verification, real-time messaging, group management, polls and announcements, LiveKit video conferencing, professional networking, file sharing, and light and dark themes.
My ChannelIQ security and data-model notes list JWT authentication with HTTP-only cookies, rate limiting, CORS, Zod input validation, bcrypt password hashing, Redis sessions, Helmet XSS protection, and CSRF protection with SameSite cookies.
My ChannelIQ Kafka event list includes USER_REGISTERED, USER_DELETED, MESSAGE_SENT, FILE_UPLOADED, and MEETING_CREATED.
My ChannelIQ setup prerequisites and commands are Node.js 20+, PostgreSQL 14+, Redis 6+, Kafka 2.8+, AWS account for S3, LiveKit Server; install, create corporatechat database, run four service migrations, configure environment, start via Docker Compose or individually.
My ChannelIQ local URLs and demo are Frontend http://localhost:3000; API Gateway http://localhost:4000; demo video https://github.com/CodeSahil21/ChannelIQ/blob/Main/docs/videos/channellQ.mp4.
My ChannelIQ performance, production, and testing guidance is Listed optimizations include code splitting, Redis caching, indexing, WebSocket pooling, CDN and gzip; production guidance includes HTTPS, clustering, monitoring, logging and backups; tests are documented but no results supplied.
My ChannelIQ license, author, support, and contribution details are MIT License; author Sahil Singh; support@channeliQ.com; contribution workflow fork, feature branch, commit, push, pull request.
My Learnit project is licensed under the MIT License.
I maintain Learnit, my learning management system repository on GitHub. The README presents it as a full-stack LMS for course management and student progress tracking; these notes reflect README documentation and do not independently verify that every described feature or endpoint is implemented.
My Learnit repository dates are Started 2025-12, last updated 2026-04.
My Learnit backend stack is Node.js with Express.js; TypeScript; Prisma with PostgreSQL; Zod; JWT; bcryptjs; PDFKit.
My Learnit frontend stack is React 18 with TypeScript; Vite; Redux Toolkit; React Router; Tailwind CSS; Shadcn/ui.
My Learnit database setup is PostgreSQL primary database; Prisma schema and migrations.
My Learnit role-based access control covers Student, Mentor, Admin.
In Learnit, Mentors require admin approval before creating courses; unapproved mentors have limited access.
In Learnit, Students must complete chapters in sequence; previous chapters must be completed before accessing next.
In Learnit, Progress percentage calculated automatically.
My Learnit security measures are JWT authentication; role-based authorization middleware; bcrypt password hashing; Zod input validation; Prisma SQL injection protection; CORS configuration.
My Learnit project structure is React client in client/; Node.js server in server/; server organized into controllers, services, routes, middlewares, utils, config, and types.
My Learnit prerequisites are Node.js v18 or higher; PostgreSQL v13 or higher; npm or yarn.
My Learnit example environment is DATABASE_URL="postgresql://username:password@localhost:5432/lms_db"; JWT_SECRET="your-super-secret-jwt-key"; PORT=4000.
My Learnit documented API endpoints are Authentication: POST /api/auth/register, POST /api/auth/login, GET /api/auth/me; users: GET /api/users, GET /api/users/search-students, POST /api/users, PUT /api/users/:id/approve-mentor, PUT /api/users/:id/reject-mentor, DELETE /api/users/:id; courses: GET /api/courses, GET /api/courses/my, GET /api/courses/:id, POST /api/courses, PUT /api/courses/:id, DELETE /api/courses/:id; chapters: GET /api/courses/:id/chapters, GET /api/courses/:courseId/chapters/:chapterId, POST /api/courses/:id/chapters; enrollment: POST /api/courses/:id/assign, POST /api/courses/:id/assign/bulk, GET /api/courses/:id/students; progress: GET /api/progress/my, POST /api/progress/:chapterId/complete, GET /api/courses/:id/progress; admin analytics: GET /api/admin/courses, GET /api/admin/enrollments, GET /api/admin/stats; certificates: GET /api/certificates/:courseId.
My Learnit database entities and relationships are Users, Courses, Chapters, Enrollments, Progress; users own courses as mentors and enroll in courses as students; chapter completion tracked through Progress.
My Learnit course capabilities are Sequential chapters with video and image media support; individual and bulk student assignment; progress tracking; rosters and student search.
My Learnit certificate feature is Automatic PDF certificate generation; certificates are available only after 100% course completion.
My Learnit project design intent is Inspired by educational platform best practices; designed for scalability and maintainability.
For backend setup, I change into the server directory, install dependencies, copy the example environment file, configure database credentials and a JWT secret, generate the Prisma client, deploy migrations, optionally seed the database, and start the development server.
cd server
npm install
cp .env.example .env
npx prisma generate
npx prisma migrate deploy
npx prisma db seed
npm run dev
For frontend setup, I install dependencies in the client directory and run its development server. For deployment, the README instructs me to configure production environment variables, run database migrations, build and start the backend, then build the frontend and serve its dist folder with a web server.
cd client
npm install
npm run dev
npm run build
npm start
I also maintain a personal portfolio repository on GitHub, presented through a README titled “My Portfolio.”
My portfolio repository is TypeScript.
My portfolio repository dates are Started 2026-04, last updated 2026-10.
My portfolio README describes it as “clean, fast, and lethal.”
My portfolio README gives this stack: Next.js • React • TypeScript • Tailwind • Framer Motion • Vercel.
I sum up the portfolio README with: “No fluff. Just code, design, and smooth motion.”
My portfolio repository is on @CodeSahil21's GitHub.
I built my portfolio with Next.js 14.
I describe MicroServices as my LetsChat microservices project: an event-driven platform for chat, video meetings, and file sharing. Its README documents the architecture and operational features below, but does not provide implementation results or benchmarks.
My local-development prerequisites are Node.js 18+ and npm; Docker Desktop; Git.
My README lists these local verification endpoints: API Gateway: http://localhost:3000; Auth: http://localhost:3001/health; User: http://localhost:3002/health; Chat: http://localhost:3003/health; Meeting: http://localhost:3004/health.
I designate Kafka events as Durable & Reliable.
My event catalog includes Kafka authentication events, user events, and meeting events, as well as Redis chat events. The README labels Kafka as “Durable & Reliable” and Redis as “Real-time”; its specific event names are recorded in the event architecture section above.
My Redis chat event catalog is chat.message.sent, chat.message.received, chat.user.typing, chat.user.online, chat.user.offline.
My example database, Kafka, and Redis settings are DATABASE_URL=postgresql://user:pass@localhost:5432/dbname; KAFKA_BROKERS=localhost:9092; KAFKA_CLIENT_ID=letschat-service; REDIS_URL=redis://localhost:6379.
My example JWT settings are JWT_SECRET=your-secret-key; JWT_EXPIRES_IN=7d.
My example LiveKit settings are LIVEKIT_API_KEY=your-api-key; LIVEKIT_API_SECRET=your-api-secret; LIVEKIT_WS_URL=ws://localhost:7880.
My README lists these documented security controls: JWT Authentication with refresh tokens; Rate limiting on all endpoints; Input validation and sanitization; CORS protection with configurable origins; Helmet.js security headers; File upload validation with virus scanning; Environment variable validation; Database connection encryption.
My README lists these observability features: Health checks for all services; Structured logging with correlation IDs; Prometheus metrics; Jaeger distributed tracing; Sentry error tracking; APM performance monitoring.
When I add a service, the documented steps are Create service directory with standard structure; add Dockerfile and package.json; update docker-compose.yml; add service routes to API Gateway.
My contribution workflow is Fork the repository; create a feature branch; make changes; add tests for new functionality; run the test suite; submit a pull request.
My README lists these support channels: Inline code comments and type definitions; repository issues; GitHub Discussions; private security issue reporting.
My API Gateway contains middleware for authentication and security.
My API Gateway routes proxy requests to services.
My API Gateway has shared service-client utilities.
My auth-service middleware includes JWT validation and rate limiting.
My auth-service contains utilities for JWT and Kafka events.
My auth-service has a Prisma database schema at prisma/schema.prisma.
My user-service routes provide user CRUD endpoints.
My user-service contains user business logic in its services.
My user-service utilities handle Kafka events.
My user-service has a Prisma database schema at prisma/schema.prisma.
My chat-service routes expose chat API endpoints.
My chat-service services contain Socket.IO and chat logic.
My chat-service utilities include Redis and Kafka utilities.
My chat-service has a Prisma database schema at prisma/schema.prisma.
My meeting-service routes expose meeting API endpoints.
My meeting-service utilities publish Kafka events.
My meeting-service has a Prisma database schema at prisma/schema.prisma.
My shared libraries include a Kafka client and event handling in kafka-event-bus.ts.
My shared libraries include Redis real-time messaging in redis-chat-event-bus.ts.
My shared libraries include inter-service communication in service-client.ts.
My shared libraries include structured logging in logger.ts.
My shared libraries include health-check utilities in health-checker.ts.
My shared libraries include a circuit-breaker implementation in circuit-breaker.ts.
My shared libraries include file-upload validation in file-upload-security.ts.
My shared libraries define shared TypeScript types in types.ts.
My test setup is configured in setup.ts.
My test environment setup is in global-setup.ts.
My test cleanup is in global-teardown.ts.
My local environment can be started with docker-compose up -d.
My production images can be built with docker-compose -f docker-compose.prod.yml build.
My production deployment example runs docker-compose -f docker-compose.prod.yml up -d --scale auth-service=3.
My Kafka authentication event catalog includes auth.user.login.
My Kafka authentication event catalog includes auth.user.logout.
My Kafka authentication event catalog includes auth.password.reset.requested.
My Kafka user event catalog includes user.profile.updated.
My Kafka meeting event catalog includes meeting.user.joined.
My Kafka meeting event catalog includes meeting.user.left.
My project is licensed under the MIT License.
My MicroServices repository is TypeScript, 1 star.
My MicroServices repository dates are Started 2025-07, last updated 2025-07.
I document the frontend routing through an API Gateway to four services. Each service has a corresponding database; Auth, User, Chat, and Meeting connect to Kafka, Chat also connects to Redis and Socket.IO, and Meeting connects to LiveKit SFU.
My documented service ports are API Gateway :3000; Auth Service :3001; User Service :3002; Chat Service :3003; Meeting Service :3004.
In my documented topology, Auth, User, Chat, and Meeting each have a database and connect to Kafka Event Bus.
In my documented topology, Chat connects to Redis Cache and Socket.IO Real-time; Meeting connects to LiveKit SFU.
My README lists these Kafka event categories: User Events: Registration, Profile Updates, Authentication; Meeting Events: Creation, Join/Leave, Recording; System Events: Health Checks, Deployments; Audit Events: Security, Compliance, Analytics.
My README lists these Redis real-time categories: Chat Messages: Instant delivery, typing indicators; User Presence: Online/offline status; Room Management: Join/leave notifications; Live Updates: Message reactions, read receipts.
My README documents JWT Authentication - Secure token-based authentication with refresh tokens.
My README documents Video Meetings - High-quality video calls powered by LiveKit SFU.
My README documents Event-Driven Architecture - Kafka for reliable inter-service communication.
My README documents Security First - Rate limiting, input validation, CORS protection.
My README documents Auto-scaling - Horizontal scaling with Docker and container orchestration.
My README documents Testing - Unit, integration, and security test suites.
I also describe user profiles and friend systems, secure file uploads with validation and scanning, push notifications, health checks and observability, Docker containerization, automated testing and deployment pipelines, and connection pooling, caching, and optimization. These are README claims; the supplied material does not verify them independently or report test results, benchmarks, or measured performance.
My README describes the platform as production-ready and enterprise-grade.
My README lists real-time chat as instant messaging with Socket.IO and Redis.
My README describes user management as complete user profiles and friend systems.
My README describes file sharing as secure file uploads with validation and scanning.
My README lists push notifications as real-time alerts and status updates.
My README identifies Redis Pub/Sub as the mechanism for instant message delivery.
My README claims comprehensive health checks and observability.
My README describes Docker containerization as a complete container orchestration setup.
My README describes the project as CI/CD-ready, with automated testing and deployment pipelines.
My README describes the project as performance optimized, citing connection pooling, caching, and optimization.
My README describes the project as security hardened and using industry-standard security practices.
I describe VendorClause-Ai as a legal-document intelligence project. Its README calls the product VendorClause-ai but describes the platform as PolyGot; the README does not explain the naming difference. The design covers a multi-service workspace, local infrastructure, PDF ingestion, hybrid retrieval, and streaming chat.
For local development, I bring up the supporting services with Docker Compose, then run the Gateway, AI service processes, and client separately. The instructions use PowerShell and describe the setup and request flow below.
My local-development infrastructure starts with docker-compose up -d from the repository root.
The Docker Compose setup starts PostgreSQL (5432), Redis (6379), MinIO (9000, console 9001), Qdrant (6333), Neo4j (7474, bolt 7687), MongoDB (27017), Ollama (11434), and Langfuse (3300).
I configure the Gateway by installing its npm dependencies, creating Gateway/.env from the documented development settings, deploying Prisma migrations, and starting its development server. The example environment sets PORT=4000, FRONTEND_URL=http://localhost:3400, and JWT_EXPIRES_IN=7d; it also includes database, JWT, SMTP, Redis, MinIO, MCP URL, and optional MCP authentication settings. I replace example credentials and secrets for any real deployment.
My Gateway example database connection is DATABASE_URL=postgresql://gateway_user:gateway_secure_pass_2024@localhost:5432/gateway_db.
My Gateway example uses SMTP_HOST=smtp.example.com for SMTP configuration.
My Gateway example points the Qdrant MCP service to QDRANT_MCP_URL=http://localhost:8001.
My Gateway runs locally at http://localhost:4000.
cd Gateway
npm install
npx prisma migrate deploy
npm run dev
I prepare the AI service with a Python virtual environment, install requirements.txt, and copy .env.example to .env. The quick start calls out LLAMA_CLOUD_API_KEY, OPENAI_API_KEY, and MCP_AUTH_KEY if used; it does not enumerate every required environment variable.
I start 4 AI service processes in separate terminals: the Qdrant MCP server, Neo4j MCP server, ingestion worker, and retrieval query worker.
python -m src.mcp_servers.qdrant_mcp_server
python -m src.mcp_servers.neo4j_mcp_server
python -m src.ingestion.worker
python -m src.retrieval.query_worker
My client uses NEXT_PUBLIC_API_URL=http://localhost:4000/api/v1 and runs locally at http://localhost:3400.
cd client
npm install
npm run dev
My documented runtime flow has 7 steps: the client uploads a PDF; Gateway stores it in MinIO and enqueues ingestion through BullMQ; the ingestion worker parses, chunks, embeds, and writes to Qdrant/Neo4j; Gateway publishes chat queries to Redis; the query worker runs the retrieval graph and publishes streaming events; and Gateway forwards the response to the client using Socket.IO.
When login or upload fails, I check that NEXT_PUBLIC_API_URL and FRONTEND_URL agree on the client and Gateway ports. If ingestion does not start, I check Gateway's Redis connection and BullMQ initialization; for missing status updates, I check Redis pub/sub and the Gateway Socket.IO bridge. Retrieval troubleshooting includes checking both MCP servers, and empty vector or graph stores call for checking Qdrant and Neo4j container health.
# From the project root
docker-compose up -d
docker-compose ps
docker-compose logs -f
docker-compose down
My project currently has no explicit open-source license file.
My VendorClause-Ai repository is TypeScript, 2 stars.
The VendorClause-Ai repository dates are Started 2026-03, last updated 2026-10.
PolyGot is described as an end-to-end AI document intelligence platform for legal-style workflows.
- The product capability listed in my README is: Secure auth and session management
- The product capability listed in my README is: PDF upload and asynchronous ingestion
- The product capability listed in my README is: Hybrid retrieval (vector + graph)
- The product capability listed in my README is: Streaming, source-grounded chat answers
My local Docker Compose infrastructure lists these services: Postgres, Redis, MinIO, Qdrant, Neo4j, MongoDB, Ollama, Langfuse.
The workspace separates the Next.js client, the Node.js/Express Gateway, and Python ingestion and retrieval workers with MCP servers. The Gateway handles authentication, sessions, uploads, queue production, and the Socket.IO bridge. The client communicates with it using REST and cookies; retrieval requests and stream events pass through Redis.
The frontend framework versions in my README are Next.js 16, React 19.
In the ingestion design, the client uploads a PDF; the Gateway stores it in MinIO and creates a Document and a Job in QUEUED status. It adds a BullMQ job to the document-ingestion queue with the name process-document. The worker validates jobId, documentId, and pdfUrl, then marks the Job IN_PROGRESS and Document PROCESSING before downloading the PDF from a minio://bucket/key URL to a temporary file.
The pipeline parses PDFs with LlamaParse markdown extraction, chunks them with DocumentChunker and metadata, then runs parallel extraction and indexing. VectorIndexer indexes all chunks into Qdrant using HuggingFace dense and Splade sparse representations. GraphExtractor handles high-value chunks and falls back to all chunks; Neo4jService creates the document node and stores graph documents. The Job and Document finish as COMPLETED and READY, and job progress and status events are published.
The README's ingestion diagram says: GraphExtractor on high-value chunks
The graph extraction threshold in my ingestion design is importance >= 2.
For retrieval, the workflow starts at supervisor and rewriter. Complex queries go through decomposer before mcp_orchestrator; simple queries go directly to mcp_orchestrator. Results pass through bridge_fusion and crag_evaluator. Sufficient results proceed to generator; insufficient results return to rewriter while crag_iteration < 2. Partial results, or crag_iteration >= 2, proceed to generation. The README does not explain the retry limit or how sufficiency is determined.
The retrieval retry condition is crag_iteration < 2; partial or crag_iteration >= 2 goes to generation.
The README lists Docker Desktop (or Docker Engine with Compose), Node.js 20+, npm, and Python 3.11+ (recommended) as prerequisites. It links a demo at ./assets/VendorClause.mp4 and recommends keeping the file under approximately 25–50 MB for faster GitHub loading; the README does not establish whether the file is present or its actual size.
The README's demo-size recommendation is: Tip: Keep the file under ~25-50 MB for faster loading on GitHub.
My VendorClause-Ai repository has 2 stars.
My MicroServices repository has 1 star.
My Civi-Sense repository has 1 fork.
I describe myself on GitHub as a software engineer crafting solutions in code and an open-source enthusiast who is learning, building, and collaborating.
My GitHub username is @CodeSahil21, and my profile lists sahil.s39026@gmail.com as my contact email.
I have been on GitHub since 2023.
My GitHub profile lists 1 follower.
The supplied profile lists 16 repositories.
Across the listed repositories, the language counts are TypeScript (11), Java (2), JavaScript (1), and Python (1).
I have 20 merged pull requests listed for shivamdarekar/Civic-issue.
The Civic-issue pull-request titles cover frontend and PWA work, AI additions, backend setup and fixes, issue and ward management, administration, and municipal roles. The repository description characterizes the platform as geo-fenced and offline-first, built around real municipal workflows, field constraints, and role-based governance.
I am an AI & Full-Stack Engineer focused on distributed systems and microservices, based in Mumbai, Maharashtra, India. I build production-grade multi-agent architectures and resilient, low-latency distributed systems, bridging agentic AI with robust backend infrastructure.
I present myself as a Full-Stack Developer, Backend Engineer, and AI Builder.
I build scalable products from UI to infrastructure.
My CodeSahil21 GitHub repository started in 2026-05 and was last updated in 2026-05: Started 2026-05, last updated 2026-05.
My CGPA is 7.73 / 10.
I earned an NPTEL - Computer Networks and Internet Protocols certification from IIT Kharagpur with a score of 72/100.
I have solved 500+ DSA problems across LeetCode, Codeforces, and GeeksforGeeks.
My current focus areas are Full-Stack Development, Backend Engineering, AI Systems.
My interests are Distributed Systems, Event-Driven Architecture, System Design, Product Building.
I enjoy turning ideas into polished full-stack products.
I build Frontends with React and Next.js that feel fast, usable, and clean.
I build backend systems with Node.js, Java, Kafka, Redis, and WebSockets.
I build AI workflows with LangChain, LangGraph, MCP, vector search, and knowledge graphs.
I build deployment-ready products with Docker, Kubernetes, GitHub Actions, and AWS.
My listed languages are Java, Python, JavaScript, TypeScript, SQL.
My listed full-stack and distributed-systems technologies are Node.js, React, Next.js, TypeScript, Tailwind CSS, Apache Kafka, Redis, WebSockets, Socket.IO, Microservices Architecture, Event-Driven Architecture, System Design.
My listed databases and AI systems are PostgreSQL, MongoDB, PostGIS, Prisma, Qdrant, Neo4j, Knowledge Graphs, MCP, LangChain, LangGraph, RAG Systems.
My listed infrastructure and DevOps tools are Git, Docker, Kubernetes, Helm, GitHub Actions, AWS (EC2, S3, RDS), Postman, Prometheus, Grafana, Loki, BullMQ, Langfuse.
I describe ChannelIQ as a Slack-like communication platform with microservices, real-time chat, Kafka, Redis, and WebSocket traffic handling.
I describe VendorClause-Ai as a legal document intelligence platform with async ingestion, hybrid retrieval, graph indexing, and streaming answers.
My Gateway stack is Node.js, Express, Prisma, BullMQ, Redis, MinIO, and Socket.IO.
My AI Service stack is Python, LangGraph, LangChain, LlamaParse, Qdrant, and Neo4j.
My query worker connects to a Qdrant MCP Server.
My query worker connects to a Neo4j MCP Server.
I describe Civic-issue as a geo-spatial civic workflow platform with PostGIS ward mapping, role-based dashboards, and SLA tracking.
I describe Learnit as a learning management system built with a modern TypeScript stack.
I describe portfolio as a personal portfolio and showcase site.
I describe MicroServices as a microservices-focused repository and experimentation space.
I describe GenAi as a generative AI learning and experimentation repo.
I describe JAVA-DSA as Java data structures and algorithms practice.
I list EchoRay as an additional TypeScript project repository.
I describe GoFleet as an Uber-like web app built with modern web technologies.
I describe Projects as a collection of web development projects and implementations.
I describe Web-Development-Tutorials as a web development learning and tutorial repository.
I describe DSA-Bootcamp-Java as Java DSA and interview prep bootcamp notes.
My GitHub README reports 15+ public repositories.
I state my focus areas as full-stack apps, distributed systems, AI workflows, and backend platforms.
The most active languages across my recent repos are TypeScript, Java, Python, and JavaScript.
My README's quote of the day is: “The best way to predict the future is to build it.”
I invite people to reach out about backend engineering, distributed systems, AI workflows, or full-stack product development.
I joined ASX on 2026-11-06.
I am looking forward to meeting folks on the platform.
I hope to make meaningful connections on the platform.
I have not specified what ASX refers to or shared further details about my plans there.
- I work across multi-agent systems, Deep Agents, hybrid retrieval, MCP tool integration, observability and evaluations, event-driven microservices, real-time communication, caching, WebSockets, full-stack development, cloud infrastructure, CI/CD, and telemetry. I focus on production stability, performance profiling, cost efficiency, deterministic workflows, and keeping heavy workloads off the database hot path.
I report scaling event-driven microservices to handle sub-100ms real-time communication.
I report optimizing LLM agent latency by ~90%.
My role is AI Engineer Intern at Codiste PVT LTD (Jul. 2026 - Oct. 2026), Ahmedabad, India.
I studied at PARUL INSTITUTE OF ENGG. AND TECH., LIMDA, VAGHODIA 037 (2023 to 2027).
I studied at Thakur College of Science & Commerce: 12th, science (Aug 2021 to May 2023).
My technical areas include LangGraph, MCP, RAG, Node.js, Kafka, Redis, WebSockets, Qdrant, Neo4j, LangSmith, Langfuse, Docker, Kubernetes, Helm, PostgreSQL/PostGIS, Prometheus, Grafana, and Loki. My listed skills also include Generative AI, Distributed Systems, Cloud Computing, Apollo GraphQL, JavaScript/TypeScript, Python, Java, C, React.js, Next.js, Express.js, Tailwind CSS, Prisma ORM, MySQL, and MongoDB.
I list English and Hindi, both at Full professional proficiency. My email is sahil.s39026@gmail.com, my portfolio is https://codesahil21-dev.vercel.app, and my GitHub is https://github.com/CodeSahil21.
I maintain Civic-issue, a geo-fenced, offline-first digital platform for Vadodara Municipal Corporation (VMC), framed in its README as both a hackathon MVP and a system intended for field use. The documentation describes a scalable MVP focused on real municipal workflows, field constraints, and role-based governance; it does not report measured outcomes or confirm implementation status for individual features.
My Civic-issue repository metadata is TypeScript; started 2026-01; last updated 2026-01.
The Civic-issue README identifies these problems: Incorrect ward assignment due to manual location selection; delays caused by paperwork and call-based reporting; no support for offline reporting by field staff; limited transparency and accountability in issue resolution.
The Civic-issue solution combines GPS-based issue reporting; geo-fencing with municipal ward boundaries; offline-first Progressive Web App (PWA); automated issue assignment to the correct ward engineer; clear issue lifecycle tracking and verification.
The platform supports proactive identification of civic issues during daily field surveys instead of relying only on citizen complaints.
My documented offline field workflow is: Capture GPS location automatically; upload before/after photos; submit issues without internet connectivity; background sync when network becomes available; IndexedDB for local storage; Service Workers for caching and sync.
My AI categorization prototype uses TensorFlow.js–based image analysis; suggests likely issue category (e.g., pothole, drainage); decision-support tool, not an auto-decision engine.
My ward detection method uses PostGIS spatial queries (Point-in-Polygon) to map GPS coordinates to the correct municipal ward and automatically assign the issue to the responsible ward engineer.
My documented Civic-issue roles are Field Worker; Ward Engineer; Zone Officer; Super Admin; each role sees only relevant data and actions.
My documented issue lifecycle is OPEN → ASSIGNED → IN_PROGRESS → RESOLVED → VERIFIED; SLA target calculation and breach indicators; full action history and audit trail.
The frontend issue detail page shows ward number and one-click “Open in Map” button; redirects to Google Maps or MapMyIndia (web/app).
My documented Civic-issue technology stack is Frontend: Next.js 14 (App Router), TypeScript, Tailwind CSS, Redux Toolkit, Progressive Web App (PWA), IndexedDB, TensorFlow.js; backend: Node.js, Express.js, TypeScript, Prisma ORM, PostgreSQL, PostGIS; Cloudinary image storage.
My location strategy is GPS coordinates captured on frontend using browser APIs; backend PostGIS detects the correct ward via geo-fencing; address resolution optional; map navigation handled entirely on frontend using map links; avoids dependency on paid or restricted map APIs.
My README lists Redis, advanced AI pipelines, and production map APIs are planned enhancements beyond the hackathon MVP.
The documented workflows give field workers GPS capture, photos, and offline issue reporting; ward engineers manage ward-assigned issues, progress, resolutions, and completion proof; zone officers monitor wards, verify resolutions, and oversee SLA compliance; and super admins manage roles, assignments, reassignments, and system-wide analytics. The PWA is installable on mobile and uses IndexedDB and Service Workers for local storage, caching, and sync.
The README describes a project structure with backend ward-boundary data, Prisma schema and seed files, middleware, auth/issues/users/admin modules, services, utilities, and app/index entry points; the frontend has auth, field-worker, ward-engineer, zone-officer, and admin areas alongside components, hooks, Redux, public assets, and libraries. It also names Cloudinary for image storage and OpenStreetMap / Google Maps for navigation. No ward count, boundary-data source, or boundary-loading procedure is specified.
My local setup prerequisites are Node.js 18+; PostgreSQL with PostGIS enabled; Git.
Backend: cd backend; npm install; cp .env.example .env; npx prisma generate; npx prisma db push; npm run dev. Frontend: cd frontend; npm install; cp .env.example .env.local; npm run dev
The README does not provide specific SLA durations or breach thresholds, authentication details, environment-variable names, database configuration, deployment instructions, image-model or training-data details, categorization accuracy, or measured performance, usage, deployment, or ward-detection results. It describes the system and intended stack but does not establish which features are implemented.
My Civic-issue repository is on @CodeSahil21's GitHub.
My AI categorization prototype is described as easily extendable for production-scale AI models.
The README says the identified reporting problems result in slow response times, unresolved complaints, and reduced public trust.
My README says engineers can directly start navigation to the issue location.