assignment.md

��Express Analytics  |  Intern Take-Home Assignment

EXPRESS ANALYTICS
AI/ML Engineer Intern

TAKE-HOME ASSIGNMENT
RAG-Based Technical Documentation Assistant

Build a Retrieval-Augmented Generation system with a self-corrective LangGraph workflow

Role: AI/ML Engineer - Intern

Duration: 2 days

Submission: GitHub Repository + README

Stack: Python, LangGraph, FastAPI

Please read the entire document before starting.

Overview

Build a RAG-powered technical documentation assistant that can answer questions about a set of
technical documents (e.g., Python library docs, API references, or framework guides). The system should
use a LangGraph workflow with retrieval, document grading, and answer generation nodes. It should be
served via a simple FastAPI application.

This assignment evaluates your ability to build a RAG pipeline, work with LangGraph�s graph-based
workflows. There is no single correct architecture � we want to see how you think.

Scenario

You are provided with a small corpus of technical documentation (3�5 documents, such as pages from a
Python library�s official docs, README files, or API references). A user submits a natural language
question, and your system should retrieve the most relevant chunks, verify their relevance, generate an
answer with citations, and handle cases where the retrieved context is insufficient.

You may choose the corpus yourself � for example, you could use documentation from LangChain,
FastAPI, Pydantic, or any other technical project you find interesting. Provide the documents (or URLs to
fetch them) in your repository.

System Architecture

LangGraph Workflow

Your system should be implemented as a LangGraph StateGraph with the following nodes. You may add
additional nodes if you see fit.

Node 1: Query Analysis

Takes the user�s raw question and prepares it for retrieval. This node should:

�  Rewrite or expand the query to improve retrieval quality (e.g., add synonyms, clarify ambiguity)

CONFIDENTIAL Page 1

Express Analytics  |  Intern Take-Home Assignment

�  Optionally classify the query type (conceptual, how-to, troubleshooting, API reference) to guide

downstream processing

Node 2: Retrieval

Searches the vector store for relevant document chunks. This node should:

�  Use a vector store (e.g., ChromaDB, FAISS) to perform similarity search
�  Return the top-k most relevant chunks along with their source metadata

Node 3: Document Grading

Evaluates whether the retrieved documents are actually relevant to the question. This is the
self-corrective component of the pipeline. The node should:

�  Use an LLM to grade each retrieved chunk as �relevant� or �irrelevant�
�

If all documents are irrelevant, route to a fallback path (e.g., rewrite the query and re-retrieve, or
return an �I don�t know� response)
If some documents are relevant, filter out the irrelevant ones and proceed

�

Node 4: Generation

Generates the final answer using the relevant documents as context. This node should:

�  Use an LLM to generate a clear, accurate answer grounded in the retrieved context
�

Include citations or references to the source documents in the response

Conditional Edges (Routing Logic)

Your graph should include at least one conditional edge that routes based on the document grading
outcome:

�
�

If relevant documents are found ? proceed to Generation
If no relevant documents are found ? rewrite query and re-retrieve (with a retry limit).

Think carefully about your state schema. What data flows between nodes? How do you track the
number of retries? This is a core evaluation criterion.

Document Ingestion Pipeline

Before the workflow can run, you need to ingest and index your technical documents. Your ingestion
pipeline should:

1.  Load documents from files (Markdown, text, or HTML) or fetch them from URLs
2.  Split documents into chunks using an appropriate strategy (consider chunk size, overlap, and

how technical content should be split)

3.  Generate embeddings for each chunk using an embedding model (e.g., OpenAI embeddings,

sentence-transformers, or any other provider)

4.  Store the embeddings in a vector store (ChromaDB or FAISS recommended for simplicity)

The ingestion can be a standalone script or run as part of application startup. Document your chunking
strategy and explain why you chose it.

CONFIDENTIAL Page 2

Express Analytics  |  Intern Take-Home Assignment

API Requirements

Serve the system via FastAPI. At minimum, your API should support the following endpoints:

Method

Endpoint

Purpose

Notes

POST

POST

GET

/query

/ingest

Submit a question

Returns answer with sources

Ingest new documents

Accepts file uploads or URLs

/documents

List indexed documents

Shows what�s in the corpus

POST

/feedback

Submit feedback on an
answer

Thumbs up/down + optional
comment

You may add additional endpoints as you see fit. Consider error handling, input validation, and meaningful
HTTP status codes.

Bonus (Optional)

These are not required but will strengthen your submission if you have time:

�  Hallucination check: Add a node that verifies the generated answer is actually supported by the

retrieved context (inspired by Self-RAG)

�  Web search fallback: If the vector store has no relevant results, fall back to a web search (e.g.,

using Tavily, Serper or Exa) before generating the answer

�  Conversation memory: Support follow-up questions by maintaining chat history within a session
�  Simple UI: A minimal Streamlit or Gradio frontend for interactive Q&A

Deliverables

�  A GitHub repository (public or private � invite us if private) containing all source code
�  A README.md with: project overview, architecture diagram or description, setup instructions

(environment, API keys, dependencies), how to run the application, example API requests and
responses, and a section on design decisions and tradeoffs

�  A working FastAPI application that can be run locally
�  The document corpus you used (or a script to fetch it)
�  A brief write-up (can be in the README) explaining: your thought process and reasoning behind
the architecture and the components of your workflow, what you would improve with more time,
any assumptions you made, and your chunking/embedding strategy choices

CONFIDENTIAL Page 3

Express Analytics  |  Intern Take-Home Assignment

LangGraph Cookbooks & References

The following official and community resources will help you understand the patterns needed for this
assignment. We strongly recommend reviewing these before you start coding.

Official LangGraph Tutorials

�  Agentic RAG Tutorial � Build a custom RAG agent with LangGraph (retrieval, grading, query

rewriting)
https://docs.langchain.com/oss/python/langgraph/agentic-rag

�  Adaptive RAG Tutorial � Combines query routing with self-corrective RAG (closest to this

assignment�s architecture)
https://langchain-ai.github.io/langgraph/tutorials/rag/langgraph_adaptive_rag/

�  Corrective RAG (CRAG) Notebook � Document grading and query rewriting patterns from the

CRAG paper
https://github.com/langchain-ai/langgraph/blob/main/examples/rag/langgraph_crag.ipynb

�  Self-RAG Blog Post � Overview of self-reflective RAG concepts and LangGraph

implementation
https://blog.langchain.com/agentic-rag-with-langgraph/

Community Tutorials

�  LangChain Open Tutorial � Adaptive RAG � Step-by-step walkthrough with groundedness

checking and web search modules
https://langchain-opentutorial.gitbook.io/langchain-opentutorial/17-langgraph/02-structures/06-langgraph-age
ntic-rag

�  FutureSmart AI � LangGraph RAG Agent Tutorial � Covers basics to multi-agent RAG, good

for understanding the progression
https://blog.futuresmart.ai/langgraph-rag-agent-tutorial-basics-to-advanced-multi-agent-ai-chatbot

Reference: Tools & APIs You Can Use

Below are some tools and APIs that may be useful. You are not limited to these � use whatever you think
is appropriate.

LLM Providers (pick one)

Provider

OpenAI

Anthropic

Groq

Notes

Free Tier

GPT-4o-mini recommended for
cost efficiency

Pay-as-you-go (low cost for this
project)

Claude 3.5 Sonnet / Haiku

Pay-as-you-go

Very fast inference, Llama & Mixtral
models

Generous free tier

Google Gemini

Gemini Flash for fast, cheap
inference

Free tier available

CONFIDENTIAL Page 4

Express Analytics  |  Intern Take-Home Assignment

Vector Stores

Tool

Notes

Free Tier

ChromaDB

FAISS

Simple, runs locally, great for
prototyping

Free, open source

Facebook�s similarity search, very
fast

Free, open source

Web Search (for bonus fallback)

API

Purpose

Free Tier

Tavily (tavily.com)

AI-optimized web search

1,000 searches/month free

Serper (serper.dev)

Google Search results via API

2,500 free queries on signup

Important Notes

�  You may use any LLM provider for the pipeline (OpenAI, Anthropic, Groq, Google, etc.)
�  Focus on getting the core RAG pipeline right before attempting bonus features
�

If you run into time constraints, prioritize the LangGraph workflow + document grading logic over
additional features

�  We value clear thinking and honest documentation of tradeoffs over feature completeness
�  Don�t hesitate to ask clarifying questions before starting

Good luck! We look forward to reviewing your work.

CONFIDENTIAL Page 5