AI-App Craftsman

AI-App Craftsman

From Python to Azure Agent Deployment in 5 days

Rebuild your engineering muscle for the AI era, culminating in Azure AI Foundry-ready apps.

AI isn't the future of software—it's the foundation. And if your skills have gone stale while the industry sprinted ahead, this course is your fast track back to relevance.

In five intensive days, you'll go from rusty to production-ready: sharpen your Python chops, master async patterns, wire up LLMs, chain complex reasoning, build autonomous agents, deploy to Linux, and orchestrate everything through Azure AI Foundry. No fluff. No theory for theory's sake. Just the hard-won knowledge that comes from three decades in the trenches—the tradeoffs nobody mentions in blog posts, the gotchas that eat your weekend, the performance landmines you'll actually encounter.

You're not here to understand AI. You're here to ship it. By week's end, you'll prototype and deploy AI apps on enterprise infrastructure—because your employer doesn't pay you to read papers, they pay you to build.

This isn't a course. It's a retool. And you'll leave dangerous.

Disclaimer

The field of Artificial Intelligence and AI-centric application development is evolving at an exceptional pace. As such, this course outline is intended to serve as a flexible framework rather than a rigid syllabus. The instructor may revise, reorder, or substitute topics at any point during the program to ensure that the material remains current, relevant, and aligned with real-world industry practices.

Additionally, given that participants often arrive with varied technical backgrounds and differing levels of readiness, the instructor reserves the right to adapt the depth, pace, and sequence of instruction in real time to best support the overall learning experience. These adjustments may occur without prior notice, and are always made with the intent of maximizing participant engagement and practical value.

Learning Outcomes

By the end of the 5 days, students will:

• Be fluent again (or newly fluent) in modern Python, including asynchronous programming and concurrency patterns.
• Understand how to make both synchronous and asynchronous HTTP / REST / streaming API calls.
• Build web services using Flask and FastAPI that expose AI/LLM endpoints.
• Load and run lightweight LLMs locally (from Hugging Face) using CUDA or quantization (when hardware allows).
• Integrate remote LLM APIs (OpenAI, Azure, etc.) into Python code with robust prompt engineering, fallback, and tooling.
• Use chaining frameworks (e.g. LangChain) to build multi-step reasoning pipelines.
• Implement Retrieval Augmented Generation (RAG) over domain corpora.
• Build agents (tool invocation, reasoning loops) and understand architectures such as MCP.
• Deploy AI apps on Ubuntu Linux (basic ops, services, security, process management).
• Leverage Azure AI Foundry to host, monitor, version, manage and scale AI agents and models.
• Use prompt engineering strategies in development (for code generation, chain logic, Copilot assistance).
• Critically evaluate tradeoffs (latency, cost, context window, reliability, model drift) in AI app design.
• Be fully prepared to transition their prototypes into the Azure AI Foundry ecosystem.

Prerequisites

To get full value, students should enter with:

• Basic Python knowledge (functions, classes, data structures).
• Basic familiarity with REST, JSON, HTTP.
• Basic command-line / shell competence (Unix commands, file navigation).
• Experience with version control (Git).

If some participants feel weak in these, we may assign a short “pre-course reading/lab” to bring them to baseline before Day 1.

Detailed Training Guideline

Below is the full sequence of modules and submodules. Each day will combine lecture + live coding + labs + architectural critique + Q&A.

1. Python & Async Foundations + HTTP Integration

• Core Python refresher (compact but rigorous)
  • Data structures, comprehensions, slicing
  • Functions, closures, decorators, context managers
  • Modules, packages, pip/venv, import mechanics
  • Type hints, dataclasses, exception patterns
• Concurrency, I/O, asynchronous patterns
  • Blocking vs non-blocking I/O; threads, processes
  • asyncio primitives: event loop, coroutines, async/await
  • Tasks, futures, gather, wait, cancellation, timeout
  • Interfacing blocking code using executors
  • Backpressure, throttling, retry strategies
• Async HTTP / network integration
  • Using httpx (async) or aiohttp for REST calls
  • Streaming responses, chunked transfers, backpressure
  • WebSockets or Server-Sent Events basics
  • Authentication (Bearer tokens, OAuth), headers, retry logic
• Error handling, instrumentation, observability
  • Logging, tracing, correlation IDs
  • Retry/backoff, circuit-breaker patterns in async code
  • Metrics: latency, error rates

2. Web API Services: Flask & FastAPI + AI Endpoints

• Foundations of web service design
  • HTTP semantics: verbs, status codes, headers, payloads
  • JSON, serialization, validation
• Flask primer
  • App structure, routes, request/response lifecycle
  • Blueprints, error handlers, middlewares
  • Handling input validation, JSON payloads, exceptions
• FastAPI deep dive
  • Defining path operations, request/response models (Pydantic)
  • Dependency injection, background tasks
  • Async handlers, streaming responses
  • Auto-generated OpenAPI / docs, versioning
  • Mounting multiple sub-apps
• Wrapping AI endpoints
  • Designing your service interface to LLM calls (e.g. /generate, /chat)
  • Throttling, batching, fallback logic
  • Asynchronous chaining of multiple calls
  • Rate-limiting, concurrency controls
• Service architecture considerations
  • Clean layering (handlers, services, utils)
  • Configuration management, secrets (e.g. storing API keys)
  • Error propagation and fallback paths

3. Local Model Inference (Hugging Face) + Prompt Engineering + Remote LLM Integration

• Intro to local inference
  • Why run models locally (privacy, latency, offline use)
  • Limitations (GPU, VRAM, quantization)
  • Simple inference: transformers library usage
    • AutoModelForCausalLM / LlamaForCausalLM + tokenizer
  • Moving model to GPU: model.to("cuda") (when PyTorch + CUDA installed)
  • Use of accelerate, quantization, 8-bit or 4-bit variants (bitsandbytes)
  • Example with Qwen-2.5 model locally: installing drivers, PyTorch+CUDA, loading the model
• Quantization / memory optimizations (overview)
  • Tradeoffs: precision vs memory vs throughput
  • Loading large models with memory-mapped, 4-bit, 8-bit techniques
  • Offloading, CPU fallback for unsupported operations
  • Handling OOM / memory overflow gracefully
• Prompt engineering fundamentals
  • Prompt templates, few-shot, chain-of-thought
  • Guardrails, prompt injection risks, fallback prompts
  • Prompt versioning and tracking (e.g. prompt logs, prompt unit tests)
  • Prompt strategies for Copilot / code generation (how to prime Copilot)
• Remote LLM API integration
  • Using OpenAI / Azure OpenAI / other LLM-as-a-service endpoints
  • Authentication, batching, backoff, error handling
  • Prompt wrapping, fallback to local inference (hybrid)
  • Latency tradeoffs, cost modeling

4. Chaining, RAG, Agents, and MCP

• Chaining & reasoning pipelines
  • Concept: chains, nodes, memory, branching
  • LangChain (or analogous frameworks): chains, agents, retrievers
  • Building simple chains: e.g. summarization→follow-up→analysis
  • Debugging chains, instrumentation
• Retrieval Augmented Generation (RAG)
  • Indexing documents: embeddings, vector stores (FAISS, Pinecone, etc.)
  • Similarity search, re-ranking
  • Grounding prompts with retrieved context
  • Dealing with hallucination, context window limits
  • Hybrid: local + remote retrieval
• Agent architectures & tool invocation
  • Agent as controller: planning, tool selection, re-plan, loop
  • Tool wrappers (search, calculator, browser, code execution, database)
  • Single-step router, planner agents, hierarchical agents
  • Fallback, abort, error paths
• Model Context Protocol (MCP)
  • What is MCP: a standard for tool + context interaction (exposing data/tools via MCP server, connecting with AI clients)
  • MCP server / client architecture, JSON RPC contract
  • Integrating MCP with agent frameworks (e.g. LangChain adapters)
  • Use case: agent calling your own MCP-exposed tools (e.g. internal search, domain logic)
  • Interaction between RAG and MCP: retrieval context vs tool invocation
    • e.g. use MCP server for deterministic data access, and RAG to deliver context
• Multi-agent orchestration & safety
  • Agent-to-agent coordination, delegation
  • Logging, tracing, fallback, safe stop
  • Observability, debugging strategies
• Hands-on lab
  • Build a small agent that:
    • retrieves context via RAG
    • invokes domain tool(s) via MCP
    • returns answer, handles fallback
  • Instrument, test, log, debug

5. Deployment, OS, CI/CD & Azure AI Foundry Integration

• POSIX / Linux basics
  • File structure, users, permissions, networking basics
  • Process management: systemd, supervisord, logs
  • Reverse proxy (Nginx), SSL/TLS, firewalls
  • Monitoring basics: logs, top, resource usage
  • Containerization & deployment (if time permits)
    • Dockerizing the app (Flask/FastAPI + agent logic)
    • Container management, orchestration (optional lightweight)
  • CI/CD & pipeline setup
    • GitHub Actions / Azure Pipelines: build, test, deploy
    • Environment variables, secrets management
    • Staging vs production configurations
  • Deploying to Ubuntu VM / server
    • Transfer, installation, virtual environment, dependencies
    • Systemd services wrapping the app
    • Logs, metrics, restarts, health checks
• Introduction & deep tie-in to Azure AI Foundry
  • What is Azure AI Foundry: a unified PaaS for AI apps, agents, model & tool management, monitoring & governance
  • How it integrates model, agent, and tool pipelines under one resource portal
  • Agent runtime: Azure AI Foundry Agent Service — managing thread orchestration, tool invocation, safety, identity, logging, scale
  • How your local chaining / agent prototyping maps to Foundry runtime
  • How model catalog, versioning, governance, experiment tracking, RBAC, monitoring are handled inside Foundry
  • How to package your agent / chain for deployment into a Foundry project
  • Mapping your Python service (Flask / FastAPI + agent logic) into Foundry SDK / APIs
  • Transition strategies: prototyping locally → pushing to Foundry
  • Best practices, pitfalls, performance considerations (latency, model swap, cost)
• Prompt engineering & Copilot in deployment phase
  • Prompts for chain orchestration, fallback logic
  • Strategies to use Copilot: prompting, verifying, scaffolding
  • Code review, unit tests around Copilot output

When they finish, they won’t just “understand Foundry” - they will have built working agents in the style Foundry expects, and be ready to migrate, scale, and maintain them in production.