Title: Final Capstone Project
Course: AIINFRA 300: Agentic AI & the Model Context Protocol (MCP) > Section: Week 16 — Capstone Project & Course Review

🎓 Final Capstone Project (100 pts)

This is the culminating project for AIINFRA 300. You will design and partially prototype a real agentic system that draws on the skills you built across Weeks 1–15 — reasoning/acting loops, tool use, custom API-backed CLI design, MCP server/client design, multi-agent orchestration, and production-readiness (human-in-the-loop, security, error handling, evaluation). You do not need to build a polished, production-grade product. You need to demonstrate that you can make and justify good engineering decisions, communicate them clearly, and get a real (if small) piece of it running.

Choose your system

Pick one agentic system to design. Some starting ideas (you are welcome to propose your own):

- A research-assistant agent that uses MCP to query a document store and a web-search tool, then synthesizes a cited answer.
- A DevOps helper agent that connects to an MCP server exposing safe, read-only infrastructure inspection tools (e.g., "list running containers," "read recent logs").
- An API research assistant that wraps one public API as a small CLI first (doctor, search, get, --json), then exposes the best command as an MCP tool for an agent.
- A customer-support triage agent that orchestrates a knowledge-base tool and a ticketing tool through MCP, with a human-approval step before any ticket is closed.
- A personal-productivity agent that connects a calendar tool and a task-list tool via MCP and negotiates conflicts between them.

Whatever you choose, it must involve at least one API-backed CLI command you define, at least one MCP server you define (even minimally), and at least two distinct tools/capabilities the agent can call.

Requirements

1. Written design document (3–5 pages, or equivalent in a Notion/Google Doc). For each decision, explicitly name which week's skill it draws on. At minimum, address:
  - Problem and users — what the agent does and who it's for.
  - Agent architecture — the reasoning/acting loop you're using and why (Weeks 1–3).
  - Tools and function-calling design — the tool schemas you defined, inputs/outputs, and how the agent decides which tool to call (Weeks 4–6).
  - CLI/API design — how your command-line interface maps to the underlying API, how auth/config is handled, and what structured output or compound command makes it useful to an agent (Week 10).
  - MCP design — what your MCP server exposes (resources, tools, prompts as applicable), how it reuses or wraps your CLI/API logic, and how a client connects to it (Weeks 7–10).
  - Orchestration — if more than one agent or tool chain is involved, how state and context are passed between steps (Weeks 10–12).
  - Production readiness — human-in-the-loop checkpoints, authentication/authorization approach, error handling strategy, and how you would evaluate whether the agent is behaving correctly before shipping it to real users (Weeks 13–15).
  - Known limitations and what you'd do with more time.
2. Diagram — one clear architecture diagram (hand-drawn and photographed, or made with a free tool such as draw.io, Excalidraw, or Mermaid) showing the user, CLI, external API, agent, MCP server(s), tools/resources exposed, and the flow of a typical request end to end.
3. Working prototype artifact — a real, runnable piece of your system, built with free or low-cost tools from this course's toolchain (e.g., Python, an MCP SDK, a local or free-tier LLM API, Docker). It does not have to cover the whole design — it must demonstrate at least one full round trip: an agent making a decision, calling a tool through MCP, and returning a result. Include:
  - Source code (zipped or a link to a public/private repo).
  - A short README with setup and run instructions.
  - A CLI demo command showing at least one successful API-backed result, preferably with a structured --json or equivalent output mode.
  - Evidence it runs — a screen recording, screenshots of terminal output, or logs.

Deliverables

- [ ] Design document (PDF or shared doc link)
- [ ] Architecture diagram (image or PDF, embedded in or attached alongside the design document)
- [ ] Prototype source code (zip upload or repo link) with README
- [ ] Evidence the prototype runs (screenshots, logs, or short recording)

Submit all of the above as a single upload (zip) or as text entry containing links to each deliverable. Graded with the Capstone / Project Rubric (100 pts). This assignment maps to all five course outcomes: CLO1–CLO5.