Building an AI Agent

Navigate project folders and run commands in the macOS Terminal.

Create and run a Python script using a local code editor.

Use variables, numeric types, strings, booleans, and type conversions in Python.

Build expressions with arithmetic, comparison, and Boolean operators.

Control program behavior with conditional statements.

Process repeated operations with for and while loops.

Define and call functions with parameters and return values.

Interpret a Python traceback to locate and correct a basic programming error.

Select an appropriate Python list, tuple, or set for a given data-handling task.

Store and retrieve keyed information with Python dictionaries.

Transform collections with list and dictionary comprehensions.

Extract and normalize information using common string operations.

Read and write text files safely with pathlib and context managers.

Organize reusable code into modules and import it into another script.

Create a virtual environment and install a package with pip.

Write and run a focused unit test for a Python function.

Parse JSON into Python objects and serialize Python objects as JSON.

Add type hints to make a function's input and output contracts explicit.

Define a validated data model with Pydantic.

Handle invalid input with exceptions and clear error messages.

Explain the roles of requests, responses, endpoints, and status codes in an HTTP API.

Send a request to an API from Python and inspect its response.

Implement a simple local API endpoint with FastAPI.

Test a local API endpoint with normal, missing, and invalid inputs.

Distinguish rule-based programs, machine-learning models, language models, and AI agents.

Explain how tokenization and context windows affect a language model's input.

Explain next-token prediction as the core operation of a generative language model.

Predict how temperature and sampling settings affect generated responses.

Calculate simple vector-similarity scores to explain semantic retrieval.

Diagram an agent loop that observes, selects an action, uses a tool, and returns a result.

Distinguish prompting, retrieval-augmented generation, conversational memory, and fine-tuning.

Classify examples of hallucination, prompt injection, unsafe tool use, and private-data leakage.

Define the prototype's intended clinician use and explicitly exclude diagnosis and autonomous treatment decisions.

Distinguish patients, encounters, conditions, medications, observations, laboratory results, and clinical notes.

Separate structured clinical fields from unstructured narrative text in a sample record.

Explain how FHIR resources and clinical terminologies support interoperable health information.

Identify direct identifiers and sensitive health information in example records.

Create fictional patient records that contain no real personal or health information.

Attach source, author, and timestamp metadata to each synthetic clinical fact.

Apply a patient identifier consistently across related synthetic records.

Explain tables, rows, keys, and relationships in a relational patient-data store.

Create a SQLite schema for synthetic patients, encounters, medications, results, and notes.

Insert validated synthetic patient records into SQLite from Python.

Retrieve a single patient's information with filtered SQL queries.

Combine related patient information with SQL joins.

Prevent SQL injection by using parameterized queries.

Access the patient database through a tested Python repository function.

Record a minimal audit event when a patient-data retrieval function is called.

Select a local model size and quantization appropriate for a Mac with 16 GB of memory.

Install a local model runtime and download a suitable openly available model.

Run a local language model and verify that inference remains on the computer.

Distinguish system instructions, user requests, retrieved context, and model responses.

Write a system prompt that limits the assistant to patient-information retrieval.

Elicit a structured JSON response that conforms to a defined schema.

Design a prompt that requires the model to acknowledge missing or uncertain information.

Evaluate a prompt against a small set of ordinary and misleading clinician requests.

Define a tool contract with a name, purpose, validated arguments, and bounded output.

Implement a patient lookup tool that handles ambiguous names without guessing.

Implement a tool that returns a chronological patient timeline.

Implement a tool that retrieves medications and laboratory results for a selected patient.

Implement keyword search over synthetic clinical notes.

Connect a local language model to one validated patient-information tool.

Execute a bounded agent loop that can select among multiple retrieval tools.

Enforce argument validation, tool-call limits, and safe stopping conditions in the agent loop.

Split synthetic clinical notes into retrieval chunks while preserving patient and source metadata.

Generate local embeddings for synthetic note chunks.

Store embeddings and metadata in a local vector index.

Retrieve note chunks by semantic similarity to a clinician's question.

Restrict semantic retrieval to the currently selected patient.

Rerank retrieved evidence using simple relevance rules.

Generate an answer that cites the source and date of each supporting note excerpt.

Return an explicit no-evidence response when retrieval does not support an answer.

Build a local Streamlit chat interface for clinician questions.

Maintain the selected fictional patient and conversation state across interface interactions.

Require explicit patient confirmation before displaying retrieved clinical details.

Present medications, results, and timeline events in readable structured sections.

Display source and timestamp information alongside generated summaries.

Show understandable interface messages for invalid input, model failure, and empty retrieval.

Connect the interface to the bounded agent and patient-data tools.

Run an end-to-end scenario from patient selection to a cited answer.

Create an evaluation set of clinician questions with expected patient-specific evidence.

Measure exact-match accuracy for deterministic patient-data retrieval.

Calculate precision and recall for retrieved clinical-note evidence.

Score generated answers for factual support using their cited sources.

Test whether the agent refuses unsupported diagnosis and treatment requests.

Test for cross-patient data leakage using adversarial questions.

Test resistance to prompt-injection text embedded in a synthetic clinical note.

Create a regression test suite for the prototype's critical safety behaviors.

Explain why a synthetic-data prototype is not automatically suitable for real patient information.

Map data minimization, purpose limitation, and retention principles to the prototype's data flow.

Distinguish the general roles of HIPAA, GDPR, local law, and organizational policy without treating the course as legal advice.

Create a threat model covering unauthorized access, data leakage, unsafe outputs, and service failure.

Explain how encryption in transit and at rest protects production patient information.

Design role-based access and patient-scoped authorization for a future production version.

Specify privacy-preserving audit logs and a retention policy for a future production version.

Produce a go/no-go checklist covering clinical validation, human oversight, security review, privacy review, monitoring, and incident response.