AI/ML Engineer Jobs in Kochi – Generative AI, LLM, Python Developer

What matters most

• Deploy LLM applications and scalable RAG

  The posting explicitly calls for designing and deploying Generative AI applications and building scalable RAG pipelines. Prepare to explain an end-to-end design, including retrieval, generation, evaluation, and deployment decisions.

• Build agentic workflows with LangGraph

  Developing AI agents and agentic workflows using LangGraph is a stated responsibility. Prepare to describe workflow state, tool use, and how you would handle failures.

• Connect NLP with structured knowledge

  The role includes NLP solutions, knowledge graphs, and semantic layers. Prepare to explain when structured relationships would add value alongside text-based retrieval; the posting does not specify a particular use case.

• Engineer scalable APIs and data access

  The posting calls for Python and FastAPI APIs, SQL/NoSQL performance optimization, and contributions to microservices and scalable architecture. Prepare to walk through design and performance trade-offs across those components.

• Deliver through established engineering practices

  CI/CD, Git workflows, and code review are listed responsibilities. Prepare an example of how you would test, review, and release changes to an AI application. Cloud platforms and MLOps are listed as good to have, not required.

Likely challenges to think through

• Retrieval quality versus response speed

  A likely design challenge—not a confirmed DigitalXNode problem—is keeping a scalable RAG pipeline responsive without weakening retrieval quality. Prepare to discuss how you would measure answer quality and latency, then choose where to spend retrieval and generation time.

• Agent flexibility versus predictability

  Agentic workflows can support varied tasks but introduce more paths and failure modes. Prepare to explain when a constrained LangGraph workflow is preferable to greater agent autonomy, and how you would test and recover from failed steps.

• AI features versus service performance

  Combining LLM applications with FastAPI services and SQL/NoSQL access may require balancing application complexity against throughput and maintainability. Prepare to trace a request across the API, data layer, and AI workflow and explain where you would measure and address bottlenecks.

Topics to prepare

• LLM and Generative AI application design

  Required: the role designs and deploys LLM-based applications. Sketch an application architecture and explain how you would evaluate output quality and handle unreliable responses; these are suggested discussion points, not stated employer requirements.

• Scalable RAG pipelines

  Required: the posting calls for scalable RAG pipelines. Diagram retrieval, context assembly and generation, then explain how you would diagnose a relevant document being missed. Treat the diagnostic approach as preparation, not a prescribed company process.

• Agentic workflow orchestration

  Required: the role develops AI agents using LangGraph and asks for LangGraph or orchestration experience. Draw a small workflow with branching and a failure path, and explain when it is preferable to a simpler sequence.

• NLP, knowledge graphs and semantic layers

  Required responsibilities include NLP solutions and work with knowledge graphs and semantic layers. Explain, using a sample question, what each could contribute and where the information would enter an application; this example is a revision exercise, not a stated project.

• SQL and NoSQL performance concepts

  Required: strong SQL and NoSQL knowledge, with database performance optimization among the responsibilities. Compare data-access patterns for the same application and identify what measurements would reveal a slow query or lookup.

• Scalable system architecture

  Required: system design and scalable architecture; the role also contributes to microservices. Sketch the boundaries between an API, a retrieval pipeline and data storage, then discuss capacity and failure trade-offs without assuming a particular infrastructure.

Skills to revise

• Build a Python and FastAPI endpoint

  Required: Python, FastAPI and API development. As a revision exercise, implement an endpoint that accepts a question and returns a structured response, then test invalid input and error handling; the endpoint design is suggested practice.

• Assemble and troubleshoot a RAG flow

  Required: hands-on LLM and RAG work. Practice connecting document retrieval to an LLM response, then inspect a case where the retrieved context does not support the answer. A vector database is only good to have in this posting.

• Implement a LangGraph workflow

  Required responsibility: build agentic workflows using LangGraph. Practice a small multi-step graph with a branch and a recoverable failure, and explain the state passed between steps; the particular workflow is a practice suggestion.

• Tune SQL and NoSQL access

  Required responsibility: optimize SQL and NoSQL database performance. Write representative reads for each, inspect their performance, make one targeted change and explain the before-and-after result; no specific database product is required.

• Review an API service design

  Required: contribute to microservices and scalable systems. Practice presenting a FastAPI service boundary, its data interactions and how it handles an unavailable dependency; the failure scenario is suggested interview preparation.

• Work through delivery and code review

  Stated responsibility: follow CI/CD, Git workflows and code review practices. Practice reviewing a small Python change, recording actionable feedback and explaining how you would verify it before integration; the posting does not specify a CI/CD platform.

• Prepare an LLM and RAG project walkthrough

  The posting calls for deployed LLM applications and scalable RAG pipelines. Prepare a diagram and concise account of a project you can discuss: retrieval design, evaluation, scaling choices, results and trade-offs. If no project is available, label it as a proposed design.

• Sketch a LangGraph workflow

  The role specifies AI agents and LangGraph or other workflow orchestration. Prepare a small workflow diagram showing state, decision points, tool use and how failures would be handled; distinguish implemented work from design choices.

• Select an NLP example

  The posting includes NLP solutions, knowledge graphs and semantic layers. Prepare one relevant example or proposed approach, explaining the data representation, the NLP task and how you would check its output.

• Practice a Python API and data exercise

  The role requires Python, FastAPI and SQL/NoSQL knowledge. Draft an API contract for an LLM-backed service and explain database choices, a performance bottleneck and how you would investigate it.

• Draw a scalable system design

  The posting mentions system architecture and microservices. Sketch how an API, retrieval pipeline, model calls and data stores could fit together; be ready to explain scaling and reliability trade-offs as design suggestions, not company architecture.

• Assemble delivery-practice evidence

  CI/CD, Git and code reviews are listed responsibilities. Prepare a brief account of your own contribution to a change, including review feedback and release checks. If relevant, note cloud, vector-database or MLOps work separately as good-to-have experience.

• Map examples to the stated requirements

  Make a one-page evidence table for AI/ML and GenAI, LLMs, RAG, NLP, orchestration, Python/FastAPI, databases and system design. Record only verifiable examples; the posting states 3–10 years of experience, with flexibility up to 12 for exceptional candidates, and welcomes graduates from other fields with relevant experience.

• Write focused questions for DigitalXNode

  Bring questions about the first LLM or NLP problems to tackle, how RAG and agent workflows are evaluated, and the boundaries of the engineer’s architecture responsibilities. Confirm practical expectations for the advertised Kochi hybrid role and India work shift.