Ishu Kumar
Software Developer
JavaScript
Node JS
Python
TypeScript
SQL
Experimentation & Evaluation: 5/10
MLOps & Deployment: 5/10
Data Pipeline & Feature Engineering: 4/10
Active 5 days ago
+91 (9172) 322578 Invite to interview
Message
Download CVCV
Overview
Technical skills
Timeline
Roles
Overview
RAG/LLM engineer (mid-level to senior) who builds end-to-end retrieval-augmented systems and LLM orchestration pipelines. The strongest proven skill is system-level RAG engineering and evaluation, evidenced by the LangGraph-based graph orchestration (src/core/generation/graph.py) and the RAGEvaluator + benchmark runner (src/core/evaluation/evaluator.py and benchmark/main.py). There is little or no public evidence of custom training loops, novel model architectures, large-scale GPU optimizations or dedicated test suites in the codebase.
Technical skills
JavaScript
Node JS• Middle
Python• Senior
TypeScript• Junior
SQL
Node JS
Express
Prisma
Axios
Python
Alembic
Asyncio
Uvicorn
FastAPI
Pydantic
SQLAlchemy
Databases
Qdrant
SQLite
Apache Kafka
PostgreSQL
Redis
AI/ML
Embeddings
LangChain
LangGraph
LLM
Prompt Engineering
RAG
OpenAI SDK
Frontend
Next.js
React.js
Tailwind CSS
Vite
React Query
Zustand
Zod
Recharts
DevOps
Docker Compose
GCP
Git
Rest API
WebRTC
Docker
Mobile
Firebase
QA
Jest
Playwright
Timeline
Adaptive Rag
AI/ML
- Built an adaptive RAG system with per-workspace knowledge bases: document upload, context-aware chunking, indexing, and chat-style querying.
- Implemented a FastAPI backend with JWT auth, workspace/session management, and async ingestion pipelines using Qdrant (vector store) and MongoDB (persistence).
- Added multi-format ingestion: batch PDF parsing via Grobid plus Markdown conversion, chunking, and indexing.
- Orchestrated query routing using LangGraph (index vs general vs web-search) with Tavily search augmentation for context-aware answers.
Python
LangGraph
LangChain
Qdrant
OpenAI SDK
Ollama
Indian Institute of Information Technology, Surat
Bachelor's Degree •
Information Technology
Software Engineer Intern
•
Junior
Arjun Travel Service
•
Internship
Worked as a software engineering intern on a production travel-booking platform. Developed end-to-end features spanning React UIs and FastAPI services backed by PostgreSQL. Implemented authentication and backend logic with async processing, structured error handling, and performance-focused query work. Containerized services and integrated supporting components for production readiness.
Python
FastAPI
PostgreSQL
Docker
Redis
Apache Kafka
SQLAlchemy
Pydantic
Senior AI/ML Engineer
Confidence: High LLM Engineer
RAG/LLM engineer (mid-level to senior) who builds end-to-end retrieval-augmented systems and LLM orchestration pipelines. The strongest proven skill is system-level RAG engineering and evaluation, evidenced by the LangGraph-based graph orchestration (src/core/generation/graph.py) and the RAGEvaluator + benchmark runner (src/core/evaluation/evaluator.py and benchmark/main.py). There is little or no public evidence of custom training loops, novel model architectures, large-scale GPU optimizations or dedicated test suites in the codebase.
Model Architecture & Training
2/10
How well models are designed and trained
Minimal model-building or training code; mostly inference wrappers and embedding clients rather than custom architectures or training loops.
Evidence
src/core/retrieval/embedder.py: Embedder using Ollama embeddings and encode/embed_query functions
src/core/reranking/reranker.py: reranker scaffold that loads a model and exposes a rerank method (inference-focused)
Data Pipeline & Feature Engineering
4/10
How data is prepared for models
Solid document ingestion and chunking pipeline with PDF parsing, Grobid integration and token-aware chunking logic.
Evidence
src/core/ingestion/chunk_processor.py: token_len, semantic_chunk, split_by_tokens, merge_chunks
src/core/ingestion/grobid_ingestion.py: GrobidIngestor ingest pipeline and JSON conversion
src/core/ingestion/transcoder.py: PDFTranscoder convert_to_markdown and process_pdf
Experimentation & Evaluation
5/10
How results are measured and tested
A clear evaluation and benchmarking pipeline with retrieval evaluation metrics, benchmark runner and logging utilities.
Evidence
benchmark/main.py: Benchmark class driving baseline and reranker experiments
src/core/evaluation/evaluator.py: RetrievalEngine and RAGEvaluator evaluation flow and run_benchmark
src/core/evaluation/metrics.py: compute_recall_at_k, compute_mrr, compute_ndcg_at_k and related metrics
MLOps & Deployment
5/10
How models are shipped to production
Production-focused deployment and infra pieces: gRPC server, FastAPI backend, alembic migrations, DB access patterns and a reconnecting gRPC client.
Evidence
src/grpc/server.py: gRPC service implementations for ingestion, vector store and RAG with server build/serve
src/ragify_client/client.py: RagifyClient with lazy channel creation, locking, reset and retry on UNAVAILABLE
alembic/versions/01_initial_tables.py: Alembic migration DDL for users/workspaces/sessions/upload_statuses
Computational Efficiency
3/10
How efficiently computing resources are used
Some attention to latency and efficiency (initial_k vs top_k, latency measurements, threaded/async execution) but no advanced GPU/quantization or distributed optimization code.
Evidence
src/core/evaluation/evaluator.py: retrieval latency measurement and use of initial_k vs top_k to limit reranker work
benchmark/main.py: compares retrieval vs reranker latencies in experiments
src/ragify_client/client.py: thread-safe lazy connect and reconnect logic to avoid blocking
Research Depth & Innovation
2/10
Depth of research and new ideas
System and integration work is solid but there is no evidence of novel research, paper-level implementations, or custom model/algorithm innovation.
Evidence
src/core/generation/graph.py: LangGraph-based orchestration and prompt flows (system-level design rather than novel algorithms)
src/core/reranking/reranker.py: transformer-based reranker integration (no novel algorithmic contributions)
Expertise
RAG• Middle
LLM• Middle
AI Agents & Agentic Workflows• Middle
MLOps & Model Lifecycle• Middle
Industries
Artificial Intelligence• Middle
Technologies
Python• Senior
SQL
PostgreSQL
Redis
LangGraph
Rest API
LangChain
GCP
Docker Compose
Qdrant
SQLAlchemy
WebRTC
FastAPI
Embeddings
Prompt Engineering
OpenAI SDK
Git
SQLite
Docker
Apache Kafka
LLM
RAG
Pydantic
Recommendations
- Develop production RAG services and LLM orchestration workflows that require ingestion, retrieval, reranking and evaluation (RAG pipelines and LangGraph orchestration).
- Build and maintain evaluation/benchmarking suites and retrieval tuning experiments (metrics, reranker A/B tests, latency-aware configs).
- Implement production gRPC/HTTP integration layers and background job processing for document ingestion and indexing.
- Improve model/ML maturity by adding experiment tracking, tests, and reproducible fine-tuning or reranker training pipelines if custom modeling is needed.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Middle Backend Developer
Confidence: Medium API Engineer
Senior-level backend API engineer specializing in building retrieval-augmented generation (RAG) and production-ready LLM pipelines. The strongest proven skill is architecting end-to-end RAG systems including ingestion, chunking, embeddings, vector-store integration and a LangGraph-based generation pipeline as shown by the generation/ingestion/retrieval modules and gRPC facade. Public code does not show an extensive migration history, formal observability/tracing integration, or a documented token lifecycle and rate-limiting strategy.
API Design
6/10
How well APIs are designed
APIs are thoughtfully designed with both HTTP REST and gRPC surfaces, consistent error handling, and single-call endpoints that perform background work. Missing formal versioning, idempotency key patterns, or a documented error contract reduce the score.
Evidence
ragify-old/apps/api/main.py: global_exception_handler and CORS + FastAPI app setup
ragify-rag/src/grpc/server.py: gRPC services exposing VectorStoreService, IngestionService and RagService
ragify-old/apps/api/src/workspace/controller.py: workspace endpoints and upload/query routes
Data Layer & Database
5/10
Working with databases
Data layer shows migrations, async SQLAlchemy models and repository patterns and some transaction use in the Node/Prisma service. There is an initial Alembic migration but limited visible migration history and no explicit isolation-level tuning.
Evidence
ragify-old/apps/api/alembic/versions/01_initial_tables.py: Alembic migration creating users, workspaces, sessions, upload_statuses
ragify-old/apps/api/src/config/db.py: async SQLAlchemy engine/session management
club-commit/apps/api/prisma/seed.ts: Prisma usage and $transaction for multi-step updates
Scalability & Performance
5/10
Handling load and speed
Performance-conscious design is present via gRPC, threaded gRPC workers, async background processing, and a reranker/benchmarking flow that measures latencies. However there is limited demonstrated caching, rate-limiting, or documented connection pooling strategies beyond standard libraries.
Evidence
ragify-rag/src/grpc/server.py: ThreadPoolExecutor-based gRPC server and worker design
ragify-old/apps/api/src/workspace/service.py: asyncio.to_thread with asyncio.wait_for timeout when invoking the RAG builder
ragify-old/apps/benchmarking/main.py: benchmark runner measuring retrieval and rerank latencies
System Architecture
5/10
Overall system structure
Clear modular architecture splits ingestion, retrieval, generation, and API layers, and a gRPC boundary for the RAG engine. System-level concerns like config/secrets and graceful degradation are present but not exhaustively implemented across services.
Evidence
ragify-old/src/ragify/generation/graph.py: LangGraph-based graph builder separating classifier, retriever, evaluator, and generator
ragify-rag/src/grpc/server.py: gRPC facade that decouples API from core RAG logic
ragify-old/README.md: architecture description showing per-workspace vector collections and infra components
Security & Auth
5/10
Protecting data and access
Authentication and basic security are implemented - bcrypt password hashing, JWT handling, HTTP bearer usage, and Pydantic validation. There is no visible token refresh/revocation lifecycle or a dependency-supply audit in the code samples provided.
Evidence
ragify-old/apps/api/src/auth/utils.py: bcrypt hashing, jwt encode/decode and HTTPBearer usage
ragify-old/apps/api/src/auth/controller.py: register/login/session endpoints
club-commit/apps/api/src/middlewares/auth.ts: requireAuth middleware in Node service
Reliability & Observability
5/10
Stability and monitoring
Reasonable reliability patterns exist: timeouts around long-running LLM calls, per-file exception handling in ingestion, basic logging, and a graceful gRPC shutdown hook. There is limited evidence of structured tracing, correlation ids, or configured retry-with-backoff policies.
Evidence
ragify-old/apps/api/src/workspace/service.py: try/except around Grobid processing and asyncio.wait_for for RAG graph calls
ragify-old/src/ragify/evaluation/evaluator.py: latency measurement instrumentation
ragify-rag/src/grpc/server.py: serve function with wait_for_termination and KeyboardInterrupt handling
Expertise
Backend AI & LLM• Middle
Databases & Vector Storage• Middle
Microservices & API Architecture• Middle
Python• Middle
Node.js• Middle
Industries
Commerce• Middle
Sports• Middle
Technologies
Node JS• Middle
Asyncio
Uvicorn
Alembic
Qdrant• mentioned only
Stack• mentioned only
Vector• mentioned only
Recommendations
- Lead development of RAG and vector-search services including ingestion pipelines, vector-store lifecycle and reranker integration.
- Build gRPC-backed microservices that expose LLM-backed query pipelines and design inter-service contracts and CI/CD for them.
- Design and implement production-grade observability and reliability: structured tracing, correlation ids, retry/backoff, and rate limits.
- Own database schema evolution and migrations with a visible migration chain and DB performance tuning for vector-backed workloads.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories:
Junior Frontend Developer
Confidence: Medium Fullstack
Full-stack web developer at a middle level specializing in React-driven frontend work and integrated frontend-backend flows. The strongest proven skill is state and API handling, demonstrated by the shared request wrapper with AbortSignal support and the react-query based session hook (ishu-codes/ragify-old/apps/web/src/lib/api.ts and .../useAuthSession.ts). There is limited evidence of advanced accessibility engineering, measured performance optimization, or a custom design system in the public code.
UI Component Architecture
4/10
How interface parts are built
Component and utility boundaries are sensible with custom hooks and small component exports, but there is limited evidence of a bespoke design system or advanced composition patterns beyond utility helpers.
Responsive & Cross-browser
4/10
Works on all screens and browsers
Responsive layout and theming are handled via Tailwind configuration and CSS custom properties with dark mode support, but there is no advanced responsive technique (container queries, RTL) evident.
Performance Optimization
4/10
Speed of the interface
Shows practical performance awareness: a shared request wrapper with AbortSignal support and usage of react-query for caching; no measured before/after telemetry or advanced bundle-splitting artifacts found.
Accessibility & Semantics
2/10
Usable for everyone
Minimal accessibility evidence in human-authored sources; base focus and theming exist but no ARIA or keyboard/focus management for custom widgets is shown.
State Management & Data Flow
5/10
Managing data in the app
Solid server-state discipline for common flows: central request wrapper, token propagation, AbortSignal support, react-query integration, and local workspace session persistence with error handling.
UX & Visual Polish
3/10
Look and feel quality
Basic visual polish and UX helpers are present (theme tokens, spinner, dark mode) but there is limited evidence of sophisticated perceived-performance techniques, skeletons, or undo patterns.
Verified artifacts
Expertise
React• Junior
Frontend Architecture & Build Tools• Junior
Modern Web Frameworks• Junior
Industries
Artificial Intelligence• Middle
Commerce• Middle
Technologies
JavaScript
TypeScript• Junior
Zustand
Tailwind CSS
Next.js
Express
Prisma
React.js
Vite
React Query
Axios
Zod
Recharts
UI• mentioned only
Vector• mentioned only
Recommendations
- Lead development of API-integrated React UIs where reliable session handling, request cancellation, and react-query caching are required.
- Implement mid-sized features that require front-to-back coordination such as authenticated workspaces, uploads, and session persistence.
- Own theming and design-token work while improving accessibility and keyboard interaction for custom widgets.
- Contribute to backend endpoints around Prisma/Express transactions and data consistency for subscription or draw workflows.
Repositories
The developer's experience in this domain has been verified based on AI analysis of the following repositories: