New opportunity

Gammastack - Python Developer - Artificial Intelligence/Machine Learning

Grep Ruby Webtech · Indore, India

About this role

Grep Ruby Webtech seeks a Senior Python Engineer focused on AI, machine learning and agentic AI to build and deploy production-grade applications in Indore, India. The posting lists 6–7 years of overall experience and requires 5+ years of hands-on Python development. The role emphasizes scalable, secure and well-governed LLM-based solutions.

Responsibilities

Develop AI/ML applications in Python, primarily with FastAPI; Django and Flask are also used. Build REST APIs and microservices that integrate AI components with backend systems.
Build and optimize RAG pipelines using LLMs, embeddings and vector databases. Develop generative AI solutions with LangChain, LangGraph and LlamaIndex, and create agents and multi-agent workflows for business process automation.
Evaluate single- and multi-agent systems for task completion, reasoning quality, tool use and workflow efficiency. Apply prompt engineering, retrieval evaluation and hallucination-reduction techniques.
Implement LLM guardrails and governance, including content filtering, output validation, safety policies, compliance and audit logging. Deploy services using AWS or GCP, Docker, Kubernetes and CI/CD; monitor production performance, cost, latency and accuracy.

Requirements

Practical experience with Django, Django REST Framework, FastAPI or Flask; knowledge of AI/ML, generative AI, LLMs, embeddings, RAG and semantic search; and hands-on experience with re-ranking, RAG evaluation, hallucination handling and LLM safety and risk controls.
Experience with LLM frameworks; Pandas, NumPy, Scikit-learn, PyTorch, TensorFlow and Hugging Face Transformers; and vector databases such as Pinecone, FAISS, Chroma, Weaviate, Milvus or pgvector.
Knowledge of AWS Bedrock, including model invocation, RAG and integration with S3, Lambda, Glue, Athena and OpenSearch. The role also calls for REST API, microservices and API security knowledge; AWS or GCP, Docker, Kubernetes and GitHub Actions or GitLab CI experience; and experience with PostgreSQL, MySQL, MongoDB or Redis. Cloud AI platforms mentioned include GCP Vertex AI, Azure OpenAI and OpenAI APIs. The posting’s structured metadata specifies a bachelor’s degree.

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

Skills for this role

PythonMachine LearningGenerative AILarge Language ModelsRAGAI agentsFastAPIDjangoDjango REST FrameworkFlaskLangChainLangGraphLlamaIndexPrompt engineeringEmbeddingsSemantic searchRe-rankingRAG evaluationLLM guardrailsPandasNumPyScikit-learnPyTorchTensorFlowHugging Face TransformersPineconeFAISSChromaWeaviateMilvus (vector database) (Milvus) (vector search) (Milvus) (vector database) (M)

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

Production Python services
The role calls for production-grade AI applications in Python, primarily with FastAPI, and REST APIs and microservices that connect AI components to backend systems. API security is also specified.
RAG quality
Building and optimizing RAG pipelines is a core duty. The posting specifically names embeddings, vector databases, re-ranking, retrieval evaluation and hallucination reduction.
Agent workflows and evaluation
The role involves agents and multi-agent workflows for business process automation, plus evaluation of task completion, reasoning quality, tool use and workflow efficiency.
LLM safety and governance
The posting calls for content filtering, output validation, safety policies, compliance and audit logging, alongside broader AI risk controls.
Deployment and production monitoring
Responsibilities include deployment with AWS or GCP, Docker, Kubernetes and CI/CD, and monitoring performance, cost, latency and accuracy.

Likely challenges to think through

Balancing retrieval quality with speed
Preparation hypothesis: re-ranking and additional retrieval steps may improve answer quality while adding latency and cost. Prepare to explain how you would compare retrieval results and answer quality against those operational measures.
Making agent behavior measurable
Preparation hypothesis: a flexible multi-agent workflow may complete more complex tasks but make failures and tool use harder to assess. Prepare an evaluation approach covering task completion, reasoning quality, tool use and workflow efficiency, as the posting requests.
Applying guardrails without blocking useful outputs
Preparation hypothesis: stricter filtering and validation may reduce risk but also reject valid responses. Prepare to discuss where checks belong, how to test their effects, and what audit logs should capture, without assuming a specific company policy.
Operating LLM services at scale
Preparation hypothesis: model and cloud-service choices may trade accuracy against latency and cost. Prepare to describe how you would monitor those measures after deployment and use the results to guide changes.

Practice your answers

Technical practice

How would you structure a Python REST API that serves an AI component?

What to coverThe posting emphasizes FastAPI, REST APIs, microservices, backend integration and API security. Suggested preparation: explain request validation, authentication, separation of inference from API logic, and how you would handle slow or failed AI calls.

How would you design a RAG pipeline from documents to a grounded answer?

What to coverThe role calls for RAG using embeddings, vector databases and LLMs. Suggested preparation: walk through indexing, semantic retrieval, context selection and answer generation, including where quality and latency trade off.

How would you diagnose poor retrieval quality in a RAG system?

What to coverThe posting explicitly mentions retrieval evaluation and re-ranking. Suggested preparation: distinguish missing relevant documents from poor ranking, describe how you would evaluate retrieved results, and explain when re-ranking is worth its cost.

How would you reduce unsupported claims in an LLM response?

What to coverPrompt engineering and hallucination handling are stated requirements. Suggested preparation: discuss grounding responses in retrieved evidence, testing prompts against failure cases, and validating answers without claiming that prompting alone guarantees accuracy.

How would you build an agent workflow for business process automation?

What to coverThe role includes single- and multi-agent workflows and names LangChain, LangGraph and LlamaIndex. Suggested preparation: explain task boundaries, tool access, state and failure handling, and when a simpler workflow would be preferable to multiple agents.

How would you evaluate single-agent and multi-agent systems?

What to coverThe posting specifies task completion, reasoning quality, tool usage and workflow efficiency as evaluation dimensions. Suggested preparation: describe test tasks, observable measures and failure analysis, including how you would compare added agent complexity with its benefits.

Where would you enforce guardrails in an LLM application?

What to coverThe role names content filtering, output validation, safety policies, compliance and audit logging. Suggested preparation: distinguish input, tool-use and output controls, and discuss the trade-off between blocking unsafe behavior and rejecting valid requests.

How would you integrate AWS Bedrock into a RAG-backed service?

What to coverThe posting requests knowledge of Bedrock model invocation and RAG integration with S3, Lambda, Glue, Athena and OpenSearch. Suggested preparation: outline how you would assign responsibilities among relevant services, keeping the architecture proportional to the use case rather than assuming all are needed.

How would you deploy and monitor a production AI service?

What to coverThe role lists AWS or GCP, Docker, Kubernetes, CI/CD, and monitoring of performance, cost, latency and accuracy. Suggested preparation: explain a deployment and rollback approach, what you would measure after release, and how operational signals would guide changes.

How would you choose libraries for the ML portion of an AI application?

What to coverThe posting lists Pandas, NumPy, Scikit-learn, PyTorch, TensorFlow and Hugging Face Transformers. Suggested preparation: compare their roles in data preparation, conventional ML and model development or use, explaining choices against the application's needs rather than assuming every library belongs in one solution.

Behavioural practice

Tell me about a time you took an AI-powered service toward production.

What to coverThe posting emphasizes production-grade, scalable AI applications; this is a suggested practice question, not a confirmed interview question. Use a real situation, your own deployment or reliability actions, and the observed result.

Describe a time evaluation revealed that an AI workflow was not working well.

What to coverThe role calls for RAG and agent evaluation; this is a suggested practice question. Give the situation, the evidence you examined, the change you made, and the measured or observed result.

Tell me about a time you balanced a safety control against application usefulness.

What to coverGuardrails and governance are explicit responsibilities; this is a suggested practice question. Describe the situation, your decision and its rationale, and what happened afterward, including any unresolved trade-off.

Describe a time you integrated an AI or ML component with a backend service.

What to coverThe posting calls for REST APIs and microservices that integrate AI/ML components with backend systems; this is a suggested practice question. Explain the integration situation, your specific actions to resolve interface or operational issues, and the result.

Sharpen your knowledge

Topics to prepare

RAG retrieval and evaluation
Posting: RAG, embeddings, semantic search, re-ranking, retrieval evaluation and hallucination handling are explicit requirements. Revision exercise: Explain how you would compare retrieval results before and after re-ranking, then identify which failures come from retrieval versus generation.
Agent design and evaluation
Posting: The role covers single- and multi-agent workflows and evaluation of task completion, reasoning quality, tool use and efficiency. Revision exercise: Sketch both designs for a business-process task and define what evidence would show that each completed it correctly.
LLM guardrails and governance
Posting: Content filtering, output validation, safety policies, compliance, audit logging and risk controls are named. Revision exercise: Trace an unsafe input and an invalid output through a proposed workflow, noting where each is blocked or logged.
Secure AI service architecture
Posting: Python REST APIs, microservices, backend integration and API security are central; FastAPI is the primary framework. Revision exercise: Diagram a request from an authenticated API through retrieval and model invocation to a validated response, identifying service boundaries.
Cloud deployment and production trade-offs
Posting: AWS or GCP, Docker, Kubernetes, CI/CD and monitoring of performance, cost, latency and accuracy are specified. Revision exercise: Walk through a deployment design and explain how a change in model or retrieval settings could affect those four measures.
Bedrock and AI/ML tooling
Posting: AWS Bedrock model invocation, RAG and integrations with S3, Lambda, Glue, Athena and OpenSearch are named, alongside ML/AI libraries including Scikit-learn, PyTorch and Hugging Face Transformers. Revision exercise: Explain the role each Bedrock integration could play in a RAG architecture, distinguishing it from model and data-processing library responsibilities.

Skills to revise

Implement a Python AI API
Practice: Build a FastAPI REST endpoint that accepts a request, invokes an AI component and returns a validated response; test invalid input and an unauthorized request. Relevance: FastAPI, Python, REST integration and API security are explicit in the posting.
Build and measure a RAG pipeline
Practice: Index a small document set with embeddings in one listed vector database, retrieve and re-rank results, then record retrieval errors and unsupported answers on a fixed question set. Relevance: The role explicitly builds and optimizes RAG and requires re-ranking, evaluation and hallucination handling.
Prototype and evaluate agent workflows
Practice: Using LangGraph, LangChain or LlamaIndex, create a small tool-using workflow and a fixed set of tasks; record completion, tool-use errors and unnecessary steps. Relevance: The posting names these frameworks and calls for agent workflows and their evaluation.
Apply guardrails to model responses
Practice: Add content filtering, output validation and audit logging to the API prototype, then test unsafe requests and malformed responses. Relevance: The posting explicitly requires LLM guardrails, governance and risk controls.
Exercise a Bedrock integration
Practice: If access is available, invoke a model through AWS Bedrock and outline how S3-stored material would enter a RAG flow; otherwise, rehearse the request and data flow without claiming an implementation. Relevance: Bedrock model invocation, RAG and S3 integration are specifically listed.
Package and observe a service
Practice: Containerize the FastAPI prototype with Docker, outline a Kubernetes deployment and a GitHub Actions or GitLab CI pipeline, and define checks for latency, cost and answer accuracy. Relevance: These deployment technologies and production monitoring measures appear in the posting.

Your preparation checklist

Map your experience to the requirements
Prepare a one-page evidence sheet with dates and concrete examples of Python development, API frameworks, AI/ML libraries, vector databases and cloud deployment. The posting specifies 5+ years of hands-on Python experience; distinguish tools you have used from those you can only discuss.
Rehearse a production AI project walkthrough
Choose a project you can substantiate. Explain your design decisions, your contribution, deployment, measured results and trade-offs, with emphasis on scalable and secure LLM-based applications where relevant.
Work through a RAG design exercise
Sketch document ingestion, embeddings, vector search, re-ranking and answer generation. Prepare a small evaluation plan covering retrieval quality, hallucinations and latency; label any hypothetical design as such.
Design the Python service boundary
Draw a FastAPI REST API and microservice design that connects an AI component to backend systems. Be ready to explain API security, data storage, error handling and how you would test the integration.
Prepare an agent evaluation example
Walk through a single- or multi-agent workflow using a relevant LLM framework, if you have one. Show how you would assess task completion, reasoning quality, tool use and workflow efficiency, including failure cases.
Show how you would govern and operate the service
Prepare a concise design for content filtering, output validation, safety policies and audit logs, alongside monitoring of accuracy, cost and latency. Explain relevant deployment choices across Docker, Kubernetes, CI/CD and AWS or GCP; review Bedrock model invocation and its listed integrations.
Bring targeted questions for the employer
Ask which AI workflows are in scope, how RAG and agents are evaluated, what governance controls are required, and which cloud platform and deployment stack the team uses. These are questions to clarify the role, not assumptions about its current systems.

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…