New opportunity

AI / GenAI Software Engineer (Junior / Associate)

Marktine Technology Solutions Pvt ltd · jaipur, India

About this role

Marktine Technology Solutions Pvt ltd seeks an AI Software Engineer in jaipur, India, to build and ship production LLM applications, with a focus on RAG pipelines and agentic workflows. The listing specifies full-time employment and 10+ years of work experience, despite the Junior / Associate title.

Responsibilities

  • Build, optimize and maintain end-to-end RAG pipelines covering document ingestion, chunking, embeddings, vector indexing, retrieval and reranking.
  • Integrate LLM APIs, including Anthropic Claude, OpenAI, Gemini and open-source models, into scalable backend services using FastAPI or Python.
  • Use AI-assisted coding tools to explore codebases, write unit tests and accelerate deployment. Design structured outputs, function and tool calling, and agent workflows using LangChain, LlamaIndex or native SDKs.
  • Implement basic evaluations, guardrails and logging to reduce hallucinations, measure retrieval quality and monitor API costs.

Core requirements:

  • Solid Python foundation, including asynchronous programming, REST APIs and clean object-oriented code, plus Git proficiency.
  • Hands-on experience with embedding models and vector databases such as Chroma, Qdrant, Pinecone or pgvector.
  • Daily use of CLI or IDE agentic coding tools such as Claude Code or Cursor, with the ability to guide agents and rigorously inspect generated code.
  • At least one shipped or working project beyond a basic chat application, such as semantic search, custom document RAG, an automated agent or a GitHub repository.

Preferred

Familiarity with Docker, Linux and basic AWS or GCP deployment; experience with Model Context Protocol or multi-agent orchestration frameworks; and exposure to front-end integration using Streamlit, Next.js or React.

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

Skills for this role

PythonFastAPIREST APIsAsynchronous programmingObject-oriented programmingGitRAGDocument ingestionEmbeddingsVector indexingVector databasesChromaQdrantPineconepgvectorRetrieval rerankingLLM APIsAnthropic ClaudeOpenAIGeminiClaude CodeCursorGitHub CopilotLangChainLlamaIndexFunction callingAI agentsLLM evaluationGuardrailsDocker into Linux? no

Your skill match

Checking your profile…

YOUR NEXT STEP

Get interview-ready for this role

A focused preparation guide, built around this job’s responsibilities and requirements.

✦ AI-generated guide
Preparation suggestions, not the employer’s actual interview questions. Always check the original posting for current requirements.
01

Understand the role

What matters most

  • Own the full RAG pipeline

    The role explicitly covers document ingestion, chunking, embeddings, vector indexing, retrieval, and reranking. Prepare to explain design choices and improvements across an end-to-end pipeline.

  • Ship LLM-backed Python services

    The listing calls for integrating commercial or open-source models into scalable FastAPI or Python services, supported by async programming, REST APIs, clean code, and Git. Prepare to discuss how an integration moves from prototype to working service.

  • Build controlled agent workflows

    Structured outputs, function and tool calling, and agent workflows are stated duties. Prepare to explain how a workflow selects tools, handles outputs, and responds when a call fails.

  • Use AI coding tools with review discipline

    The listing expects daily use of agentic coding tools to explore codebases, write unit tests, and speed deployment, while rigorously inspecting generated code. Prepare to describe a concrete review-and-test workflow.

  • Demonstrate working software and measure quality

    The listing asks for at least one shipped or working project beyond basic chat, plus basic evals, guardrails, and logging for hallucinations, retrieval quality, and API costs. Prepare to walk through a project's behavior and how its results were checked.

Likely challenges to think through

  • Balance retrieval quality against cost and speed

    A likely trade-off in the stated RAG work is that chunking, reranking, and additional model calls may improve answers while increasing latency or API cost. Prepare to compare alternatives using retrieval evaluations and cost logs; the listing does not specify target metrics.

  • Keep agent behavior dependable

    Tool calling and agent workflows can add flexibility but also create failure paths or unreliable outputs. Prepare to discuss structured-output validation, failure handling, and guardrails as approaches, not as confirmed company practices.

  • Maintain quality while coding quickly

    The advertised AI-assisted workflow emphasizes faster delivery and rigorous inspection. A likely difficulty is catching incorrect generated code without losing that speed. Prepare to explain how focused unit tests and code review would support both.

03

Practice your answers

Technical practice

How would you design document ingestion and chunking for a RAG pipeline?

What to coverPosting: The role covers document ingestion and chunking in end-to-end RAG pipelines. Suggested preparation (inference): Explain how you would preserve useful context, handle document updates, and test whether chunk size and overlap improve retrieval.

How would you choose an embedding model and vector-indexing approach?

What to coverPosting: The role calls for hands-on work with embedding models and vector databases such as Chroma, Qdrant, Pinecone, or pgvector. Suggested preparation (inference): Discuss retrieval quality, indexing and update needs, latency, and operational complexity without assuming the company uses a particular database.

When would you add reranking to retrieval, and how would you evaluate it?

What to coverPosting: Retrieval, reranking, and measuring retrieval quality are stated responsibilities. Suggested preparation (inference): Describe a baseline, a relevant test set, and the quality-versus-latency trade-off you would check before keeping a reranker.

How would you structure a Python API service around an LLM-backed feature?

What to coverPosting: The role specifies Python, REST APIs, asynchronous programming, clean object-oriented code, and FastAPI or Python backend services. Suggested preparation (inference): Explain request validation, separation of concerns, async handling of external calls, and testing of failure paths.

How would you integrate and compare LLM API or open-source model options?

What to coverPosting: The role names Anthropic Claude, OpenAI, Gemini, and open-source models as integration options. Suggested preparation (inference): Explain how you would isolate provider-specific behavior and compare output quality, latency, cost, and error handling for a defined use case.

How would you make structured outputs and tool calls reliable?

What to coverPosting: Designing structured outputs, function or tool calling, and agent workflows is part of the work. Suggested preparation (inference): Cover schema validation, safe handling of tool inputs and failures, and when a simpler fixed workflow is preferable to an agent.

How would you evaluate a RAG answer and reduce hallucinations?

What to coverPosting: The role includes basic evaluations and guardrails to reduce hallucinations. Suggested preparation (inference): Describe test cases for answer support from retrieved material, how you would inspect failures, and what the system should do when evidence is insufficient.

What would you log to troubleshoot quality and API cost in an LLM application?

What to coverPosting: Logging, retrieval quality, and API cost monitoring are explicit responsibilities. Suggested preparation (inference): Identify useful per-request signals, such as retrieval results, errors, latency, and usage, while explaining how you would avoid logging sensitive content unnecessarily.

How would you use AI-assisted coding tools without weakening code quality?

What to coverPosting: The role calls for daily use of tools such as Claude Code, Cursor, or Copilot to explore codebases, write unit tests, and speed delivery, alongside rigorous inspection of generated code. Suggested preparation (inference): Walk through task scoping, reviewing changes, running tests, and using Git to keep changes traceable.

How would you prepare an LLM backend for deployment?

What to coverPosting: Shipping production applications is central; Docker, Linux, and basic AWS or GCP deployment are listed as good to have. Suggested preparation (inference): Discuss configuration, health checks, and a deployment smoke test at a basic level, without treating a specific platform as required.

Behavioural practice

Tell me about a time you shipped a working AI project beyond a basic chat application.

What to coverPosting: A shipped or working project such as semantic search, document RAG, or an automated agent is listed as proof of work. Suggested preparation (inference): Use a real example to explain the situation, your actions, and the result, including what made the project usable.

Tell me about a time you caught a problem in AI-generated code.

What to coverPosting: The role emphasizes guiding AI coding agents and rigorously inspecting generated code. Suggested preparation (inference): Give the situation, how you verified and corrected the code, and the resulting effect on correctness or delivery.

Tell me about a time you investigated poor results in a search or RAG system.

What to coverPosting: The work includes maintaining RAG pipelines and measuring retrieval quality. Suggested preparation (inference): If you have a relevant real example, describe the situation, diagnostic actions, and measured result; otherwise, do not invent an incident.

Tell me about a time you balanced delivery speed with software reliability.

What to coverPosting: The role emphasizes building, testing, and shipping clean production software quickly. Suggested preparation (inference): Choose a real situation, explain the trade-off and safeguards you chose, and state the result without implying the employer follows a particular release process.

02

Sharpen your knowledge

Topics to prepare

  • End-to-end RAG design

    Draw a pipeline from document ingestion and chunking through embeddings, vector indexing, retrieval, and reranking. Explain what can fail at each stage. The posting explicitly calls for building and maintaining this full pipeline.

  • Embedding and retrieval choices

    Compare how chunk size, embedding choice, and reranking could change search results; explain how you would test the differences. Embedding models, vector databases, and retrieval quality are explicit priorities.

  • Structured outputs and agent workflows

    Sketch an LLM request that returns a defined structure and invokes a tool; explain how you would handle an invalid response or failed call. The role includes structured outputs, function/tool calling, and agent workflows.

  • Evaluation, guardrails, and cost

    Define a small set of questions with expected source documents, then describe checks for retrieval quality, unsupported answers, and API cost. The posting explicitly mentions basic evals, guardrails, and logging.

  • Python backend design

    Outline a REST endpoint that calls an LLM API; explain where asynchronous work, error handling, and clean object boundaries belong. The core requirements name Python async programming, REST APIs, and object-oriented code.

Skills to revise

  • Implement a document RAG pipeline

    In a small working example, ingest documents, chunk and embed them, index them in one listed vector database, then retrieve and rerank results. This directly practices the role's central responsibility.

  • Build and test an LLM-backed API

    Create a Python or FastAPI endpoint that calls one listed LLM API, validates a structured response, and has unit tests for success and failure paths. This matches the backend integration and testing work described.

  • Inspect AI-generated code

    Use a listed AI coding tool to propose a focused code change, then review its diff, run tests, correct defects, and record the result in Git. The posting expects daily AI-assisted coding with rigorous inspection.

  • Instrument a retrieval workflow

    Add logs for retrieved results, response errors, and API usage; run a small evaluation set and examine unsupported answers. This practices the stated evaluation, guardrail, logging, and cost-monitoring tasks.

  • Explain a working project

    Prepare a concise walkthrough of a working project beyond basic chat—its architecture, tests, and a design tradeoff—if you have one. The posting explicitly asks for at least one shipped or working project; this exercise does not assume you have one.

04

Your preparation checklist

  • Prepare a proof-of-work walkthrough

    Choose one shipped or working project beyond basic chat, as the listing requires. Prepare a short demo or repository tour covering its purpose, architecture, your implementation, and what works today.

  • Diagram a document RAG pipeline

    Prepare a design exercise covering ingestion, chunking, embeddings, vector indexing, retrieval, and reranking. Explain how you would choose an embedding model and a vector database such as Chroma, Qdrant, Pinecone, or pgvector.

  • Walk through a Python backend integration

    Prepare a small FastAPI or Python REST API example that calls an LLM and handles asynchronous work. Be ready to explain the code structure, unit tests, and Git history; these map to stated responsibilities and core requirements.

  • Sketch a tool-using workflow

    Show a concise design for structured outputs and function or tool calling, including how an agent decides when to invoke a tool. The listing names LangChain, LlamaIndex, and native SDKs as possible approaches, not mandatory choices.

  • Define an evaluation and monitoring plan

    Prepare a few test queries and expected results for a RAG example. Explain how you would assess retrieval quality, check for unsupported answers, apply basic guardrails, and log API costs.

  • Show how you review AI-generated code

    Prepare one concrete example of using an AI coding tool to explore code, write tests, or speed up deployment. Describe the instructions you gave it and how you inspected and corrected its output; the listing emphasizes rigorous review.

  • Bring targeted questions for the employer

    Ask which RAG and agent workflows are priorities, what deployment environment is used, and how success is measured. Clarify the listing’s Junior / Associate title alongside its stated 10+ years of work experience.

AI-generated from the job information · Prepared Sep 30, 2026 (UTC)Useful preparation, not a guarantee of eligibility or an offer.

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…