AI Engineering

Transform and validate customer-support text using Python string operations.

Import standard-library modules and organize reusable code across local modules.

Install a third-party package and record the project's dependencies.

Read from and write to text files using context managers.

Encode Python data as JSON and decode JSON into Python data.

Handle expected failures with exceptions without hiding unexpected errors.

Add type hints to function parameters and return values.

Define a simple Python class that represents a support ticket.

Navigate directories and manage files using common terminal commands.

Create a Git repository and record changes with staged, descriptive commits.

Create a Git branch and merge a completed change into the main branch.

Connect a local repository to GitHub and synchronize changes with a remote repository.

Interpret a Python traceback to locate the source of an error.

Use breakpoints and variable inspection to diagnose incorrect program behavior.

Write pytest unit tests for a Python function, including an edge case.

Apply automated formatting and lint checks to a Python project.

Trace the request-response flow between a client and an HTTP API.

Choose appropriate HTTP methods and status codes for common API operations.

Call a REST API with an HTTP client and extract fields from its JSON response.

Implement a FastAPI GET endpoint that returns a typed response.

Implement a FastAPI POST endpoint that validates a Pydantic request body.

Validate path and query parameters in a FastAPI endpoint.

Return a controlled API error with an appropriate status code and message.

Test a FastAPI endpoint with an automated test client.

Explain how tables, rows, primary keys, and foreign keys represent related application data.

Design a relational schema for conversations, messages, and user feedback.

Create a SQLite table and insert records using SQL.

Query records with SQL filters, ordering, and aggregate functions.

Modify and remove database records with SQL UPDATE and DELETE statements.

Open and manage a database session from Python with SQLAlchemy.

Map a Python model to a database table with an ORM.

Implement database operations that create a conversation and retrieve its ordered messages.

Distinguish rule-based software, predictive machine learning, and generative AI by the outputs they produce.

Explain how tokenization and context-window limits affect an LLM request.

Explain probabilistic next-token generation at a conceptual level.

Describe the role of attention in a transformer at a conceptual level.

Differentiate pretraining, instruction tuning, fine-tuning, and inference.

Identify hallucination, nondeterminism, stale knowledge, and context loss in sample LLM outputs.

Compare language models using quality, latency, context length, cost, and privacy requirements.

Separate customer-support tasks suited to an LLM from tasks that require deterministic application logic.

Store and load an LLM API credential without placing it in source code.

Send a chat request through a Python LLM SDK and extract the returned message.

Assign system, user, and assistant messages appropriate roles in a chat request.

Write a prompt with explicit instructions, context boundaries, and success criteria.

Use few-shot examples to make a support response follow a desired pattern.

Request structured model output and validate it against a Pydantic schema.

Control response variability and length with model request parameters.

Implement a Python function that classifies and summarizes a support ticket with an LLM.

Represent a multi-turn conversation as an ordered sequence of role-tagged messages.

Select conversation history that fits within a defined context budget.

Write a support-assistant system prompt that defines scope, tone, and escalation rules.

Describe a deterministic support operation with an LLM-compatible tool schema.

Implement a local tool that retrieves ticket information from a database.

Execute an LLM-requested tool and return its result to the model.

Validate tool arguments and authorize an operation before execution.

Route an unsupported or high-risk request to a human-escalation response.

Explain when retrieval-augmented generation is preferable to relying on model memory.

Extract and normalize text plus metadata from support knowledge documents.

Split a knowledge document into chunks using an explicit chunking strategy.

Generate vector embeddings for document chunks with an embedding model.

Calculate and interpret similarity between a query vector and document vectors.

Store embeddings and metadata in a local vector index.

Retrieve the top relevant chunks for a question and filter them by metadata.

Generate a support answer grounded in retrieved passages with source citations.

Write user stories and measurable acceptance criteria for the standalone support chatbot.

Draw a component and data-flow diagram for the chatbot application.

Implement a repeatable pipeline that ingests support documents into the vector index.

Implement a retrieval service that returns passages and source metadata for a user question.

Implement a response orchestrator that combines retrieval, conversation history, and escalation rules.

Expose the chatbot through a validated FastAPI chat endpoint.

Build a Streamlit chat interface that calls the backend and displays source citations.

Persist conversations and user feedback through the chatbot's data layer.

Create a representative evaluation set of answerable, unanswerable, ambiguous, and unsafe support requests.

Calculate retrieval hit rate at a chosen value of k for a labeled evaluation set.

Score chatbot answers with a rubric for groundedness, relevance, actionability, and citation quality.

Classify a failed chatbot response as a retrieval, generation, or orchestration failure.

Record errors, latency, token usage, and estimated cost without logging sensitive message content.

Test the chatbot with prompt-injection and data-exfiltration attempts.

Apply source-trust boundaries and input-output controls to reduce prompt-injection risk.

Capture explicit user feedback and associate it with the corresponding application trace.

Separate development and production configuration while loading secrets from a secure environment.

Protect a chatbot API endpoint with a basic token-based access check.

Add timeouts, bounded retries, and exponential backoff to an external API call.

Enforce a per-client request limit and a maximum model-token budget.

Package the chatbot application as a reproducible Docker container.

Create a continuous-integration workflow that runs formatting checks and automated tests.

Deploy the containerized chatbot to a managed cloud service and verify its public health endpoint.

Create a portfolio README and demonstration that explain the architecture, evaluation results, safety controls, and design trade-offs.