a 1. Core Software Engineering
Strong Python — OOP, async/await, type hints, decorators, generators, clean exception handling.
Solid grasp of data structures, algorithms, and writing maintainable, testable, modular code.
REST / GraphQL / gRPC API design and consumption; authentication (OAuth2, API keys, JWT).
Concurrency and parallelism — threading, multiprocessing, async event loops, task queues.
Git / GitHub workflows — branching, PRs, code review, CI/CD basics.
Containerization and environments — Docker, virtual environments, dependency management.
Familiarity with at least one cloud or self-hosted deployment environment.
2. Data Connectivity & Integration (Primary Focus)
Connect to and ingest from heterogeneous sources reliably and at scale:
SQL databases — Postgres, MySQL, MSSQL, etc.: querying, schema introspection, joins, aggregations, parameterized/safe queries, connection pooling.
Existing ERP / business applications — integrating via REST/SOAP APIs, native connectors, or database-level access.
MCP (Model Context Protocol) servers — connecting agents to external tools and data sources; building and consuming MCP servers/clients.
Multiple protocols & transports — REST, GraphQL, gRPC, webhooks, WebSockets, message queues (Kafka, RabbitMQ, NATS), file/object stores (S3, NAS).
Files of all kinds — PDF, TXT, CSV, Excel, JSON, XML, HTML, and OCR-based image/document extraction.
Handle authentication, rate limiting, pagination, retries, and incremental/delta syncs.
Schema mapping, normalization, deduplication, and transformation into a unified queryable form.
Build connectors and adapters that are reusable, configurable, and resilient to source changes.
3. Data Engineering & Pipelines
Design and build end-to-end pipelines: extraction → cleaning → transformation → chunking → embedding → indexing → retrieval.
Streaming vs. batch ingestion; incremental updates and change-data-capture patterns.
Data validation, quality checks, and error handling within pipelines.
Workflow orchestration (e.g., Airflow, Prefect, n8n, or framework-native graphs).
Table-aware / structured-data processing with Pandas (aggregation, filtering, statistics) alongside unstructured retrieval.
4. Vector Databases & Retrieval (RAG)
Build and optimize Retrieval-Augmented Generation pipelines.
Vector stores — ChromaDB, plus familiarity with one or more of Pinecone, Weaviate, Qdrant, pgvector, FAISS, Milvus.
Chunking strategies (fixed, semantic, recursive, structure-aware) and metadata design.
Hybrid search (dense + sparse/BM25), reranking, query expansion, and retrieval evaluation.
Indexing strategies, namespace/collection design, and retrieval latency optimization.
5. Embeddings & NLP
Generate and use embeddings — HuggingFace, Sentence-Transformers, and API-based embedding models.
Embedding model selection, dimensionality, and similarity metrics.
Text normalization, lemmatization, tokenization, context-aware chunking, semantic similarity search.
Document parsing, layout-aware extraction, and OCR integration.
6. Agentic Systems & Orchestration
Design multi-agent systems using LangGraph, CrewAI, LangChain (or equivalents like AutoGen, LlamaIndex).
Agent design patterns — planner/executor, supervisor/worker, reflection, ReAct, hierarchical and collaborative agents.
Intelligent routing across agents and data sources based on query type and intent.
State machines and graph-based control flow for deterministic, debuggable agent behavior.
Human-in-the-loop checkpoints, approvals, and interrupt/resume flows.
7. LLM Engineering & Open Weights
Experience with open-weight models (Llama, Mistral, Qwen, Gemma, etc.) — selection, hosting, and serving.
Local/self-hosted inference — vLLM, Ollama, llama.cpp, TGI, or similar.
Quantization (GGUF, AWQ, GPTQ) and trade-offs between size, latency, and quality.
Fine-tuning and adaptation — LoRA/QLoRA, instruction tuning, and when to fine-tune vs. RAG vs. prompt.
Working across both open-weight and API-based (OpenAI-compatible, Groq, Anthropic, etc.) inference backends.
8. Prompt Engineering & Optimization
Systematic prompt design — instructions, few-shot examples, role/system prompts, output formatting.
Structured outputs — JSON mode, schema enforcement, function/tool-call formatting, parsing and validation.
Prompt evaluation and iteration; A/B testing prompts against metrics.
Techniques to reduce hallucination, improve grounding, and increase determinism.
Prompt versioning and management.
9. Memory & Context Management
Context window management and token budgeting.
Short-term (conversation) and long-term (persistent) memory architectures.
Retrieval-augmented memory, summarization/compaction, and selective context injection.
Token-efficiency optimization and cost-aware context strategies.
10. Tool Use & Function Calling
Define, expose, and orchestrate tools/functions for agents (schemas, validation, error handling).
Long-running tool calls — durable, asynchronous, multi-step execution; timeouts, retries, idempotency, and state persistence.
Parallel tool execution and dependency management between calls.
MCP-based tool integration and external API/tool wiring.
11. Reasoning & Planning
Implement reasoning strategies — chain-of-thought, ReAct, tree-of-thought, self-reflection, and self-correction.
Task decomposition, planning, and multi-step agentic decision loops.
Tool selection and dynamic planning based on intermediate results.
Using reasoning-capable models effectively (controlling reasoning effort, verifying outputs).
12. Evaluation, Testing & Observability
Build evaluation harnesses — golden datasets, LLM-as-judge, regression testing for agents and RAG.
Tracing and observability — LangSmith, Langfuse, OpenTelemetry, or equivalent.
Metrics — retrieval relevance, faithfulness/groundedness, latency, cost, success rate.
Unit/integration testing for non-deterministic systems; logging and debugging agent runs.
13. Guardrails, Safety & Security
Input/output validation and content guardrails.
Prompt injection and jailbreak awareness and mitigation; tool-call sandboxing.
PII handling, data privacy, and secure secret/credential management.
Access control and least-privilege design for agent tool access.
14. Deployment, Scaling & MLOps
Deploy agentic services (FastAPI / containerized services) to production.
Scaling inference and pipelines — load handling, caching, queuing, horizontal scaling.
Monitoring, alerting, and cost tracking in production.
Familiarity with CI/CD for AI systems and model/version management.
15. Cost & Performance Optimization
Token, latency, and cost profiling; caching (semantic/prompt caching) and batching.
Model routing — using smaller/cheaper models where sufficient, escalating when needed.
Throughput and concurrency tuning for inference workloads.
16. Frontend & Delivery (Supporting)
Build interactive demos and interfaces — Streamlit, Gradio, or a basic web stack.
Streaming responses, chat UIs, and document/upload handling.
17. Collaboration & Working Style
Translate ambiguous problems into working systems; bias toward shipping.
Clear documentation of pipelines, agents, and integrations.
Comfortable iterating quickly and debugging non-deterministic behavior.
Education & Application
Education: BSc / BE / B.Tech in Computer Science or related field.
Portfolio or GitHub demonstrating real, working data pipelines, RAG systems, and agentic applications.
Pay: ₹300,000.00 - ₹500,000.00 per year
Work Location: In person
