New opportunity

Senior AI/ML Specialist

Cyncly · Kochi, India

About this role

Cyncly is hiring a Senior AI/ML Specialist for its AI Centre of Excellence in Kochi to build, fine-tune and operate on-premises large language models across its product suite. The permanent, full-time role is described as hybrid. Its five use cases are product knowledge search, document intelligence, Service Desk ticket classification and resolution drafting, developer copilot assistance, and conversational product configuration.

Responsibilities

Build supervised fine-tuning and RLHF pipelines using product, documentation and support data. Apply LoRA/QLoRA, tune and checkpoint models, manage reproducible experiments and model versions, and optimize quantized models for GPU inference. Work with Data Engineering on dataset versioning, PII scrubbing and quality checks.
Develop embedding pipelines and vector database deployments for product catalogues and documentation. Tune ingestion, indexes and filtering; evaluate retrieval with MRR, NDCG and recall@k; compare embedding upgrades; and combine dense retrieval with BM25 in hybrid search.
Implement RAG for the five use cases, connect internal data and product APIs through MCP, integrate a developer copilot, and deliver AI capabilities through REST/OpenAI-compatible APIs. Add prompt-injection defenses, output filtering and guardrails.
Build automated and human evaluation workflows, regression tests and continuous quality checks. Track BLEU, ROUGE, faithfulness, hallucination and answer relevance; maintain evaluation artifacts and a model leaderboard to inform releases and rollbacks.
Serve models on on-premises GPUs using vLLM or Text Generation Inference; monitor latency, throughput, GPU utilization and cost; support on-call incident response; and deploy reproducible workloads with Docker, Kubernetes and CI/CD. Contribute to Neo4j knowledge-graph and NLP enrichment pipelines, and prototype agentic retrieval and action workflows.

Requirements

A bachelor's or master's degree in Computer Science, AI or Machine Learning, or equivalent practical experience; 5–8 years of software and/or AI/ML engineering experience, including at least 2 years directly with LLMs or transformer-based systems. Strong Python skills and proficiency with PyTorch or JAX, the Hugging Face ecosystem, fine-tuning and quantization are required. Candidates need practical vector database, RAG and retrieval-evaluation experience; production LLM serving; experiment tracking and model evaluation; REST APIs and prompt engineering; and Docker, Kubernetes and CI/CD skills. The role also calls for tested code, experimental rigor, cross-team communication and ownership.

Preferred

Knowledge graphs and graph-augmented retrieval; Zendesk or similar ticketing integrations; agentic AI frameworks or MCP development; developer-tooling integrations; open-source ML contributions; and multimodal or vision-language model experience.

For full details about this role, click “Apply on company site” to view the employer’s original posting.

Skills for this role

PythonPyTorchJAXHugging Face TransformersHugging Face DatasetsHugging Face PEFTHugging Face AccelerateHugging Face EvaluateSupervised fine-tuningRLHFLoRAQLoRAGGUFAWQGPTQMLflowWeights & BiasesLangSmithBGE-M3E5-largeQdrantWeaviatePineconeChromaVector databasesEmbeddingsSemantic searchHybrid searchBM25RAGAS мetrics (RAGAS)

Checking your profile…

Preparation suggestions, not the employer’s actual interview questions. Always check the original posting for current requirements.

Understand the role

What matters most

Reproducible domain-model training
The role builds SFT and RLHF pipelines using product, documentation and support data, with LoRA/QLoRA, checkpointing and experiment tracking. Prepare to explain how you would version datasets and models, check data quality and scrub PII with Data Engineering.
Measured retrieval quality
The role owns embedding pipelines, vector-database indexing and filtering, and hybrid dense/BM25 search. Prepare to explain how MRR, NDCG and recall@k would guide an embedding upgrade or retrieval change.
RAG integration and safeguards
The role implements RAG across five use cases, connects internal data and product APIs through MCP, and exposes capabilities through REST/OpenAI-compatible APIs. Prepare to discuss context selection, prompt-injection defenses, output filtering and integration with Product and Engineering teams.
Release-ready model evaluation
The role calls for automated and human evaluation, regression tests, continuous checks and evaluation artifacts that inform upgrades or rollbacks. Prepare to describe how you would compare faithfulness, hallucination and answer relevance by use case before release.
Reliable on-premises inference
The role deploys models on on-premises GPUs using vLLM or TGI, monitors latency, throughput, utilization and cost, and participates in serving incident response. Prepare to discuss reproducible Docker/Kubernetes deployments and how you would investigate a serving regression.

Likely challenges to think through

Useful domain data without exposing sensitive content
Preparation hypothesis, not a stated employer problem: Product and support data may improve fine-tuning while creating PII and quality risks. Prepare a way to discuss dataset screening, scrubbing, versioning and checks before training.
One architecture, different use-case demands
Preparation hypothesis, not a stated employer problem: Search, ticket drafting, developer assistance and product configuration may need different balances of retrieval relevance, answer faithfulness and latency. Prepare to explain how you would evaluate and tune RAG separately for each use case rather than assume one setting fits all.
Model quality versus GPU serving efficiency
Preparation hypothesis, not a stated employer problem: Quantization and serving optimizations can improve throughput or latency while changing output quality. Prepare to explain how you would benchmark both model evaluations and operational metrics before an upgrade.
Automated scores versus human judgment
Preparation hypothesis, not a stated employer problem: Metrics and regression tests can flag changes, but may not capture whether a drafted resolution or product answer is genuinely useful. Prepare to describe when human review would complement automated evaluation and how results would inform a release or rollback.

Practice your answers

Technical practice

How would you design a reproducible SFT and RLHF pipeline for domain-specific LLMs?

What to coverThe posting calls for SFT and RLHF using product, documentation and support data. Suggested preparation: explain how you would choose training data, use LoRA or QLoRA, track hyperparameters and checkpoints, and compare model versions.

How would you prepare domain datasets for fine-tuning without losing traceability?

What to coverThe role involves dataset versioning, PII scrubbing and quality checks with Data Engineering. Suggested preparation: describe validation and versioning choices, and how you would trace a model result back to its dataset and training run.

How would you choose a quantized model and serving setup for on-premises GPUs?

What to coverThe posting names GGUF, AWQ and GPTQ, alongside vLLM or TGI serving. Suggested preparation: discuss memory, quality, latency and throughput trade-offs, then explain what GPU-utilization and cost measurements would inform your choice.

How would you build and scale embedding search over product catalogues and documentation?

What to coverThe role covers embedding pipelines, vector-database ingestion, indexing and filtering. Suggested preparation: explain your choices for document representation, index configuration and filters, including how you would test retrieval quality as the collection grows.

How would you determine whether hybrid search improves product discovery?

What to coverThe posting specifies dense retrieval combined with BM25 and evaluation using MRR, NDCG and recall@k. Suggested preparation: describe a fair comparison against dense-only search, including relevance judgments, ranking trade-offs and an embedding-upgrade A/B evaluation.

How would you adapt a RAG design across the five stated use cases?

What to coverThe use cases are product knowledge search, document intelligence, Service Desk ticket classification and resolution drafting, developer copilot assistance, and conversational product configuration. Suggested preparation: contrast their retrieval and output needs, and explain how you would assess context relevance, faithfulness and latency.

How would you secure integrations that expose internal data and AI capabilities?

What to coverThe posting calls for MCP connectors, REST/OpenAI-compatible APIs, developer copilot integration, prompt-injection defenses and output filtering. Suggested preparation: walk through an integration design and explain where you would enforce data-access boundaries, validate tool outputs and apply guardrails.

How would you decide whether a model update is ready for release?

What to coverThe role includes automated and human evaluation, regression tests, continuous checks, and artifacts to support upgrades or rollbacks. Suggested preparation: explain which of BLEU, ROUGE, faithfulness, hallucination rate and answer relevance suit different use cases, and how you would investigate conflicting results.

How would you troubleshoot degraded production LLM serving?

What to coverThe posting mentions on-premises serving, latency and throughput targets, operational dashboards, on-call response, and Docker/Kubernetes deployments through CI/CD. Suggested preparation: describe how you would distinguish model, GPU, traffic and deployment causes, and what evidence would support mitigation or rollback.

When might graph-augmented or agentic retrieval help beyond a standard RAG pipeline?

What to coverThe role includes contributing to Neo4j entity extraction and graph-query integration, and prototyping tool-use workflows. Suggested preparation: outline a product-knowledge scenario where relationships or multiple retrieval steps could help, plus how you would test whether the added complexity improves results.

Behavioural practice

Tell me about a time you took ownership of an ambiguous AI or software workstream.

What to coverThe posting emphasizes ownership and iterative delivery in early-stage AI work. Suggested preparation: use a real situation, the actions you took to define scope and make progress, and the result or lesson.

Describe a time you worked across teams to resolve a data-quality problem.

What to coverThe role involves collaborating with Data Engineering on datasets and quality checks. Suggested preparation: give a real situation, explain how you aligned on the problem and acted with others, and state the outcome.

Tell me about a time evaluation evidence changed a technical decision.

What to coverThe posting values clear hypotheses, rigorous tracking and evidence-based model decisions. Suggested preparation: describe the situation, your experiment or analysis, and the resulting decision and its measured effect.

Describe a time you improved the reliability of shared engineering work.

What to coverThe role calls for tested Python code, code reviews, Git workflows and shared ML infrastructure. Suggested preparation: choose a real situation, explain your contribution and collaboration, and give the result without overstating your individual impact.

Tell me about a time you communicated a production issue or quality risk to stakeholders.

What to coverThe posting includes incident response and communication with technical and non-specialist teams. Suggested preparation: set out the situation, how you explained uncertainty and coordinated action, and what happened afterward.

Sharpen your knowledge

Topics to prepare

Fine-tuning and quantization trade-offs
Posting: SFT, RLHF, LoRA/QLoRA, checkpointing and GGUF/AWQ/GPTQ are central to on-premises models. Revision exercise: explain when you would fine-tune rather than use RAG, then compare LoRA and QLoRA on memory use, reproducibility and inference implications.
Retrieval quality and hybrid search
Posting: embedding pipelines, vector indexes, filtering, BM25 hybrid search and MRR, NDCG and recall@k are explicit. Revision exercise: work through a small ranked-results example and calculate each metric; explain how you would compare an embedding upgrade.
RAG architecture and safeguards
Posting: RAG spans five use cases, with MCP connections, prompt-injection defenses, output filtering and guardrails. Revision exercise: sketch a document-intelligence request from retrieval through an OpenAI-compatible API response, identifying where untrusted retrieved text could affect the answer.
Model evaluation and release decisions
Posting: automated and human evaluation, regression tests, BLEU, ROUGE, faithfulness, hallucination rate and answer relevance inform upgrades and rollbacks. Revision exercise: define a small evaluation rubric and explain which measures would detect a fluent but unsupported resolution draft.
On-premises inference operations
Posting: GPU serving with vLLM or TGI, latency and throughput targets, GPU utilization, cost monitoring and incident response are responsibilities. Revision exercise: reason through a latency spike, separating retrieval, generation and GPU-capacity causes and proposing measurements for each.
Dataset and experiment integrity
Posting: the role calls for versioned domain datasets, PII scrubbing, quality checks, tracked runs and model artifacts. Revision exercise: outline how a training run could be reproduced and audited without retaining sensitive support-ticket details.

Skills to revise

Run a traceable PEFT experiment
Suggested practice: use synthetic support examples to run a small SFT experiment with Python, Hugging Face Transformers and PEFT; record dataset version, settings, checkpoint and evaluation result in MLflow or Weights & Biases. This rehearses the posting’s fine-tuning and reproducibility work.
Benchmark a searchable document collection
Suggested practice: ingest sample product-style documents into one listed vector database, test metadata filters, and compare dense retrieval with a BM25 hybrid approach using labeled queries and recall@k, MRR and NDCG. This mirrors the required retrieval and hybrid-search work.
Implement a guarded RAG endpoint
Suggested practice: build a small REST/OpenAI-compatible endpoint over sample documents with structured output and tests for malicious instructions embedded in retrieved text. This connects the posting’s API, RAG and prompt-injection-defense responsibilities; sample data is sufficient.
Build an evaluation regression check
Suggested practice: create a Python test set for one stated use case, such as ticket resolution drafting; score answer relevance and faithfulness, add human-review criteria, and make a model change fail a regression threshold. This reflects the requested evaluation harnesses and release checks.
Package and observe model serving
Suggested practice: write a Dockerfile and a Kubernetes or Helm deployment configuration for a vLLM or TGI service, then specify checks for request latency, tokens/sec and GPU utilization. This rehearses the stated serving, deployment and observability work without assuming access to Cyncly infrastructure.
Validate a versioned data pipeline
Suggested practice: write tested Python checks that reject malformed records and redact PII in synthetic catalogue or support data; version the input and cleaned output. This supports the posting’s data-quality, privacy and cross-team dataset-curation responsibilities.

Your preparation checklist

Map evidence to the required skills
Posting: The role requires Python, Hugging Face, fine-tuning, RAG, production serving, evaluation, and Docker/Kubernetes. Prepare a one-page evidence map pointing to specific work or code samples for each area; mark gaps rather than inventing examples.
Rehearse a fine-tuning project walkthrough
Posting: Cyncly describes SFT and RLHF pipelines, LoRA/QLoRA, quantisation, dataset quality, and reproducible tracking. Prepare an existing project walkthrough, if available, covering data handling, experiment choices, measured results, and limitations.
Sketch a product-search design
Posting: The role covers embeddings, vector databases, BM25 hybrid search, and MRR, NDCG, and recall@k. As a practice exercise, draw an ingestion-to-retrieval design for product knowledge search and a small comparison plan for two embedding approaches.
Design a guarded RAG integration
Posting: RAG spans five use cases, with MCP connectors, REST/OpenAI-compatible APIs, and prompt-injection defenses. Prepare a diagram for one stated use case showing data access, retrieval, API boundaries, output filtering, and failure handling.
Draft an evaluation and release plan
Posting: Automated and human evaluation, regression tests, continuous checks, and rollback evidence are responsibilities. Prepare a sample test matrix covering retrieval quality, faithfulness, hallucinations, answer relevance, human review, and a decision rule for a model update.
Prepare a serving and incident example
Posting: On-premises GPU serving, vLLM or TGI, latency and throughput monitoring, Docker/Kubernetes, CI/CD, and on-call response are specified. Prepare an architecture sketch and, if available, an incident example showing diagnosis, mitigation, and follow-up.
Select a cross-team ownership story
Posting: The role works with Data Engineering, QA, Product, and Platform teams and calls for experimental rigor and ownership. Prepare one real example explaining the decision, collaborators, evidence used, trade-offs, and outcome.
Write questions for the employer
Prepare questions about which of the five use cases comes first, available dataset and GPU constraints, evaluation and release criteria, and team ownership. The description says hybrid while the page’s workplace field says onsite; ask which arrangement applies.

Availability last checked: 4 Nov 2026. Status can change after a check; confirm on the employer’s website. Report an issue · Our checking policy

KEEP EXPLORING

Similar AI jobs

Related skills and specializations in India. Matched to this role, not your profile.

Explore more jobs

Finding similar opportunities…