AI, Data Science, and Machine Learning

Call an HTTP API with httpx and handle status errors, timeouts, and malformed responses.

Implement a FastAPI endpoint with Pydantic request and response schemas.

Inspect and exercise a FastAPI service through its generated OpenAPI documentation.

Define a small relational data model in SQLite with SQLAlchemy.

Implement transactional create, read, update, and delete operations for one database entity.

Load configuration from environment variables without committing sensitive values to Git.

Write an integration test that verifies an API request through to database persistence.

Explain how tokens, context windows, and autoregressive generation constrain an LLM application.

Run a quantized coding model through Ollama that fits within 6 GB of GPU memory.

Invoke an Ollama model through its local HTTP API and extract the generated response.

Construct a chat prompt with system instructions, user input, and clearly delimited context.

Validate an LLM's structured JSON output against a Pydantic schema.

Implement a context-trimming strategy that keeps a conversation within a model's input limit.

Benchmark two local models for response quality, latency, and memory use on the same coding tasks.

Calculate cosine similarity between embedding vectors and interpret the resulting ranking.

Generate text embeddings locally with a sentence-transformer model.

Split documents into retrievable chunks while preserving source and location metadata.

Create and persist a FAISS vector index from embedded chunks.

Retrieve top-k chunks for a query and apply a metadata filter to the results.

Generate an answer grounded in retrieved context with explicit source citations.

Make a retrieval-augmented assistant abstain when its indexed evidence is insufficient.

Traverse a repository while excluding ignored, generated, binary, and oversized files.

Extract functions, classes, imports, and line ranges from Python files with the ast module.

Divide source files into syntax-aware chunks that preserve symbol and location metadata.

Index code chunks and refresh only entries affected by changed files.

Combine lexical and vector search results into a ranked set of relevant code snippets.

Answer a repository question using retrieved code with file-and-line citations.

Verify that a repository answer's claims are supported by the cited source lines.

Define a machine-readable tool schema with explicit inputs, outputs, and failure cases.

Implement sandboxed tools for listing, searching, and reading repository files.

Build an agent loop that selects a tool, observes its result, and decides the next action.

Represent an agent task as explicit state that can be saved and resumed.

Enforce path boundaries and command allowlists before executing an agent-selected action.

Generate a unified code patch and require human approval before applying it.

Run targeted tests after a code change and feed the test result back into the agent loop.

Create a versioned evaluation set of repository questions, expected evidence, and coding tasks.

Measure retrieval quality with recall at k and mean reciprocal rank.

Score generated answers for relevance, citation support, and refusal when evidence is absent.

Write an end-to-end test for a repository question that requires retrieval and generation.

Test the assistant against prompt-injection attempts embedded in repository content.

Explain the security risks of arbitrary command execution and identify concrete sandbox controls.

Record structured traces for model calls, retrieval results, tool actions, latency, and failures.

Use evaluation results to improve one bottleneck without regressing the existing benchmark.

Expose repository indexing, question answering, and task execution through documented FastAPI endpoints.

Stream incremental model output from the backend to a client.

Persist projects, conversations, and task status in a local relational database.

Build a minimal Streamlit interface for selecting a repository and interacting with the assistant.

Add health checks and actionable error responses for the database, index, and local model service.

Package the application in Docker while connecting it safely to the host's Ollama service.

Configure a GitHub Actions workflow that runs formatting checks and tests on each change.

Run a clean-machine installation test by following only the project's documented setup steps.

Draw a system architecture diagram showing data flow across the interface, API, retrieval, model, tools, and storage.

Write a README that explains the problem, setup, usage, limitations, security controls, and evaluation results.

Create a concise demonstration script that shows repository ingestion, cited answers, an approved edit, and test feedback.

Explain when to choose local inference versus a hosted model API using cost, privacy, latency, and scalability criteria.

Defend the capstone's retrieval, agent-control, evaluation, and deployment trade-offs in a system-design walkthrough.

Write evidence-based résumé bullets that quantify the capstone's tested capabilities and performance.

Answer common AI Engineer interview questions about RAG, tool use, evaluation, hallucination, and prompt injection.

Audit the finished repository against a job-ready rubric and resolve its highest-impact deficiency.