Agentic AI Systems Development

Read from and write to text files with Python.

Serialize and deserialize structured data in JSON format.

Handle invalid input and failed operations with Python exceptions.

Organize reusable Python code into modules and install a package in a virtual environment.

Add type hints to function inputs and outputs and use editor feedback to identify type mismatches.

Call a public HTTP API from Python, check its response status, and extract values from its JSON response.

Write and run basic automated tests with pytest.

Use Git to make coherent commits and publish a documented, tested, API-powered command-line project to GitHub.

Explain how tokens, context windows, probabilistic generation, and hallucinations affect language-model outputs.

Call a language model from Python while keeping credentials outside the source code.

Construct prompts that separate instructions, context, examples, and requested output.

Use few-shot examples to improve a model's consistency on a classification task.

Compare generation settings on the same task and select settings appropriate for consistent application behavior.

Parse structured model output into a Pydantic model and handle validation failures.

Score model responses with a small task-specific quality rubric.

Assemble a minimal engineering-concept explainer that returns validated structured output and communicates uncertainty.

Distinguish a fixed AI workflow from an autonomous tool-using agent.

Define a narrow Python tool with a machine-readable input schema.

Register and dispatch approved tools by name while rejecting unknown tools and malformed calls.

Execute one complete model-to-tool-to-model interaction cycle.

Implement a bounded agent loop that stops after a final answer, an error condition, or a step limit.

Maintain only the conversation state needed for an agent's current task.

Add timeouts, retries, and fallback behavior to an unreliable tool call.

Build a calculation assistant that selects and uses approved engineering tools.

Explain how embeddings and vector similarity support semantic retrieval.

Extract clean text and metadata from a small collection of technical documents.

Split technical text into retrievable chunks while preserving source metadata.

Store document embeddings in a local vector database.

Retrieve and rank document chunks for a user question.

Generate an answer grounded in retrieved passages with source citations.

Measure retrieval quality with a small set of questions and expected sources.

Build a cited study assistant over engineering notes or public technical documents.

Represent an agent workflow as nodes, edges, state, and termination conditions.

Define typed shared state for a LangGraph application.

Implement LangGraph nodes that make one observable state change each.

Route execution with conditional graph edges.

Save and restore graph execution with checkpointing.

Summarize older conversation history to keep memory within a defined budget.

Pause and resume a graph for human review of a proposed action.

Refactor a previous tool-using assistant into a traceable stateful graph.

Choose among a deterministic workflow, one agent, and multiple agents using task complexity, reliability, latency, and cost criteria.

Transfer work between agents using an explicit handoff schema.

Route a request to an appropriate specialist using a supervisor pattern.

Implement a planner-reviewer workflow with an explicit completion condition and bounded revision count.

Explain the roles and trust boundaries of hosts, clients, servers, tools, and resources in the Model Context Protocol.

Connect a Python MCP client to a local read-only server and invoke a discovered tool.

Expose one read-only Python capability through an MCP server.

Integrate an MCP tool into a bounded technical design-review workflow and capture its execution trace.

Define measurable success criteria for an agentic application.

Create a versioned evaluation dataset containing normal, edge, adversarial, and expected-failure cases.

Unit-test deterministic tools without calling a language model.

Measure whether an agent selects the correct tool and supplies valid arguments.

Evaluate retrieved answers for source relevance, citation correctness, and factual support.

Use execution traces to locate a routing, retrieval, or tool-use failure.

Compare two system versions by quality, latency, and estimated cost.

Create a regression report and use it to improve one weak system behavior.

Create a threat model for an agent that reads untrusted content and invokes tools.

Demonstrate a prompt-injection attack safely in a sandboxed example.

Separate trusted instructions from untrusted data in an agent workflow.

Restrict agent tools with least-privilege permissions and explicit allowlists.

Prevent sensitive data from entering prompts, logs, or traces through data minimization and redaction.

Enforce policy checks on model-generated arguments before they reach an external action.

Require human approval and record an audit event for a consequential action.

Add at least three adversarial security tests to a portfolio agent and document its residual risks.

Expose an agent through a typed FastAPI endpoint.

Build a simple web interface for an agent with Streamlit.

Persist user sessions or task records in SQLite.

Emit structured application logs and derive request latency, failure rate, and model-usage measurements from them.

Package an agent application and its dependencies in a Docker container.

Run automated tests on each repository update with GitHub Actions.

Load production secrets from the deployment environment and enforce one basic abuse control such as an API key or request limit.

Deploy and smoke-test the container on a no-cost host, or verify it locally and document reproducible deployment steps if no suitable free tier is available.

Select and narrowly scope an employer-relevant engineering or operations problem that can be completed by reusing earlier course components.

Write user stories, constraints, and measurable acceptance criteria for the capstone.

Create an architecture diagram showing the applicable data, model, retrieval, tool, security, and control boundaries.

Implement the capstone's smallest end-to-end vertical slice using only the typed tools and retrieval components justified by its requirements.

Implement stateful orchestration with a bounded execution path and a human-approval point.

Evaluate the capstone against functional, retrieval, failure, and security test cases.

Deploy the capstone and complete a user acceptance test from a clean browser session.

Publish a reproducible project page containing setup instructions, an architecture explanation, evaluation evidence, limitations, and a short demo video.

Audit portfolio repositories against a consistent hiring-manager checklist and resolve the highest-impact gaps.

Write a concise case study explaining a project's problem, decisions, evidence, and limitations.

Translate project work into quantified resume bullet points without overstating results.

Present a focused GitHub profile and professional profile for junior AI application roles.

Explain an agentic system's architecture, failure modes, and trade-offs in a mock technical interview.

Complete a timed Python, API, and debugging exercise at an entry-level standard.

Create a repeatable job-search pipeline, identify suitable roles, and submit one tailored application.

Package one portfolio system as a fixed-scope paid pilot with defined deliverables, exclusions, timeline, and price.