Building Agentic AI Systems

Transform and inspect text using Python string operations.

Store, retrieve, and update ordered data using Python lists.

Represent keyed records and frequency counts using Python dictionaries.

Choose between tuples and sets based on immutability and uniqueness requirements.

Write functions with parameters and return values to eliminate repeated logic.

Add type hints to document the expected inputs and outputs of Python functions.

Handle anticipated failures with try-except-else-finally blocks.

Build a command-line utility that combines functions, collections, branching, and loops.

Create and manipulate platform-independent file paths with pathlib.

Read and write text files safely with Python context managers.

Read, transform, and write tabular data in CSV format.

Serialize and deserialize structured data in JSON format.

Organize reusable Python code into modules and import it correctly.

Create an isolated Python environment and install pinned third-party dependencies.

Track a Python project with Git by ignoring generated or sensitive files, staging changes, creating coherent commits, and working on a branch.

Load configuration and secrets from environment variables without committing them to source control.

Transform collections concisely with list and dictionary comprehensions.

Model a simple domain concept with a Python class containing state and behavior.

Represent structured records concisely with Python dataclasses.

Record useful runtime information with Python's logging system.

Inspect runtime state and follow program execution with an interactive debugger.

Write focused automated tests with pytest.

Replace an external dependency with a test double when testing Python code.

Publish a repository to GitHub and complete a pull-request workflow.

Explain how HTTP methods, URLs, headers, status codes, and bodies form an API exchange.

Call a public REST API with Python and extract values from its JSON response.

Validate an external API response with a Pydantic model.

Send validated data to a REST API with an HTTP POST request.

Authenticate an API request using a secret loaded from an environment variable.

Handle unsuccessful responses and network timeouts without crashing an automation.

Apply bounded retries with exponential backoff while respecting rate limits.

Build and test a small automation that transfers data between public or locally mocked API services.

Model automation data as relational tables with keys and constraints.

Create, read, update, and delete SQLite records using parameterized SQL.

Answer operational questions with SQL filtering, joins, grouping, and aggregation.

Use a database transaction to keep a multi-step data change atomic.

Create validated GET and POST endpoints with FastAPI.

Receive and validate an event through a webhook endpoint.

Use async-await to run independent I/O operations concurrently.

Combine FastAPI and SQLite into a persistent automation service.

Explain how tokens, context windows, and next-token prediction affect language-model outputs.

Select and run a quantized language model that fits within the practical limits of an 8 GB Apple Silicon Mac.

Call a local language model from Python through an HTTP API.

Write a prompt that clearly specifies context, instructions, constraints, and examples.

Generate structured output from a language model and validate it with Pydantic.

Choose between deterministic Python logic and a language-model step for an automation task.

Adjust sampling and context settings to balance consistency, quality, speed, and memory use.

Compare prompt variants against a small rubric-based evaluation set.

Explain how embeddings and similarity search support semantic retrieval.

Split source documents into retrievable chunks while preserving useful metadata.

Generate local text embeddings and store them in a local vector index.

Retrieve the most relevant document chunks for a natural-language query.

Generate an answer grounded in retrieved context with source citations.

Evaluate retrieval quality separately from answer-generation quality.

Make a grounded assistant abstain when the retrieved evidence is insufficient.

Build a local document-question-answering pipeline using retrieval-augmented generation.

Distinguish a fixed workflow, chatbot, and autonomous agent by their control flow and decision authority.

Specify an agent's goal, state, available actions, and stopping conditions.

Define a typed tool schema and obtain a validated tool-call request from a language model.

Implement a tool dispatcher that validates arguments before executing Python functions.

Implement a bounded agent loop that alternates between model decisions and tool results.

Manage an agent's working context so essential state is retained without unbounded history.

Require explicit human approval before an agent performs a consequential action.

Implement a stateful tool-using agent with a graph-based orchestration library and explicit transitions and termination conditions.

Select a deterministic workflow, single-agent design, or multi-agent design from reliability requirements.

Unit-test an agent loop's success, tool-error, refusal, and termination paths using a deterministic fake model and mocked tools.

Create a scenario-based evaluation suite for an agentic automation.

Trace an agent run with structured records of model decisions, tool calls, latency, and errors.

Make a side-effecting tool idempotent using operation identifiers.

Defend an agent against instructions embedded in untrusted retrieved content.

Enforce least-privilege access with tool allowlists and argument-level authorization.

Implement a two-role delegation workflow with a typed handoff and explicit termination.

Distinguish container images, running containers, ports, and persistent volumes.

Package a FastAPI agent service in a container with a Dockerfile.

Run a resource-limited local application stack with Docker Compose.

Create a local n8n workflow that transforms data from a manual or scheduled trigger.

Connect an n8n workflow to a Python agent service through a validated webhook.

Add a human approval gate before an n8n workflow performs an external side effect.

Run Python tests automatically on repository changes with GitHub Actions.

Expose a local webhook temporarily through a secure free tunnel and revoke access afterward.

Translate a realistic automation problem into user stories and measurable acceptance criteria.

Diagram a capstone system's components, data flow, trust boundaries, and human checkpoints.

Implement a minimal end-to-end vertical slice connecting a trigger, bounded agent decision, approval-gated tool action, and persistent audit record.

Evaluate the capstone against normal, edge-case, and adversarial scenarios, then correct its highest-priority failure.

Write a reproducible README for the capstone detailing installation, configuration, and execution steps.

Record a concise video demonstration showcasing the capstone's workflow, tool execution, and error handling.

Write evidence-based project descriptions for a résumé and GitHub profile.

Explain the capstone's architecture, tradeoffs, failures, and improvements in a mock technical interview.