🚀 Building Intelligent Apps with Anaconda

Mission status: Ready for lift-off

A hands-on curriculum for building production-grade intelligent applications with the Anaconda ecosystem. Every module is a self-contained < 7-minute narrated demo with pre-run outputs or script run_demo.sh — designed to show the code and the decisions, not walk you through setup.

Our data is real: WASP-18 b, a hot Jupiter exoplanet caught transiting its star by NASA's TESS telescope. We process its light curve, build agents to reason about it, deploy those agents to production, secure the supply chain, and ship the result — to a browser tab, to a native app, to an air-gapped server 800km away. Same data. Every module.

(Looking for conda-forge optimized environments? check out the conda-forge branch of this repository.)

---

🌌 Mission arc:

                     ┌─────────────────────────────────────────────┐
                     │         THE WASP-18 b PIPELINE              │
                     │  a hot Jupiter 1,300 light-years from home  │
                     └─────────────────────────────────────────────┘

 PRE-LAUNCH         -1   MCP orientation        ~5 mins            talk to Anaconda tools before liftoff - requires Claude Desktop
 ────────────────────────────────────────────────────────────────────────────────
 CORE STACK         00   Foundation*            ~1-3 mins          conda — the launch pad - build script
                    01   Data sources           ~1-3 mins          TESS photons → Python → ValidationReport - prerun notebook
                    02   Your first agent*      ~3 mins            one agent, one tool, one answer - build script
                    03   Multi-agent            ~5 mins            crew of agents, Metaflow orchestration - build script
 ────────────────────────────────────────────────────────────────────────────────
 DEEP SPACE         04   Deployment*            ~3 mins            swap the LLM endpoint, keep the agents - prerun notebook
                    05   GPU acceleration*      UNKNOWN            (experimental) Nemotron on NVIDIA iron, 47× faster - prerun notebook
                    06   App architecture       ~5-7 mins          harness, evals, vector memory, cards - build script
                    07   Mission critical       ~5 mins            CVEs, conda-lockfiles, air-gap, AIBOM - prerun notebook
 ────────────────────────────────────────────────────────────────────────────────
 EXTRAVEHICULAR     08   Native apps*           UNKNOWN            (experimental) PyScript (browser) + BeeWare (native) - build script
                    09   Web app                ~1-3 mins          Panel app (browser) - prerun notebook
 ────────────────────────────────────────────────────────────────────────────────
 MISSION CONTROL    --   Example environment                       reference environment that would work for all of the modules
                    --   README                                    **YOURE HERE**

All modules are optimized for GitHub codespaces for ease. Modules that cannot be completed in GH codespaces: *section #00 - mcp your environment requires Claude Desktop *section 02 - your first agent, option B requires Anaconda Desktop *section 04 - deployment and inference, option A requires Anaconda Desktop *section 05 - gpu acceleration, requires Brev (paid service) *section 08 - native applications, option B: BeeWare builds native applications

The payload — ingestion.py and ValidationReport — never changes. What changes is where it runs and what reasons about it.

---

📡 Modules

-1 — MCP: Pre-flight Checklist

Make sure ground control can hear you. Time: ~5 minutes

The Model Context Protocol is how AI assistants talk to Anaconda tools. Before the first conda install, verify your MCP setup so Claude Desktop can manage environments, query packages, and inspect CVEs on your behalf.

Tools: anaconda-mcp, Claude Desktop

---

00 — Foundation: The Launch Pad

You can't reach orbit without a stable platform. Time: ~1-3 minutes

Every agent, every pipeline step, every GPU kernel in this curriculum runs inside a conda environment. This module makes that concrete: why conda, how environment isolation works, and the tools that turn a fleeting pip install into a reproducible, lockable, shippable artifact.

Tools: conda, conda-pypi (experimental), conda-forge, Anaconda Distribution

---

01 — Data Sources: First Contact

Raw photons from 1,300 light-years away, cleaned up and ready for agents. Time: ~1-3 minutes

Built on Daina Bouquin's polars_demo — a real TESS phase-folded light curve of WASP-18 b, a hot Jupiter completing an orbit every 22 hours. We extend it into a production-ready pipeline: schema enforcement, Pydantic validation, IsolationForest anomaly detection, and the ValidationReport that every subsequent module consumes.

PHASE | LC_DETREND | MODEL_INIT
──────────────────────────────
The three columns that travel through the entire curriculum.

• ingestion.py — load_lightcurve(), validate_lightcurve(), schema enforcement
• ValidationReport — typed Pydantic output, JSON-serialisable, agent-ready
• IsolationForest — transit anomaly detection without labelled data
• agent_context — the structured payload that becomes Module 02's agent input

Tools: Polars, scikit-learn, Pydantic, ingestion.py

---

02 — Your First Agent: One Crew Member

A single agent, two tools, a classification. Time: ~3 minutes

ingestion.py functions become LangGraph tools. One agent calls load_lightcurve, passes the result to validate_lightcurve, reasons over the ValidationReport, and returns a structured transit classification. Claude Haiku is the default crew member — swap the base_url for AI Navigator or Anaconda Desktop to fly offline. Demo can be completed without model access, but stops at what will be served to the model.

Default LLM: claude-haiku-4-5-20251001 via Anthropic API, or AI Navigator local server.

Tools: LangGraph, Anthropic or openai client

---

03 — Multi-Agent Architecture: Assemble the Crew

Two agents, one supervisor, foreach parallelism across 50 targets. Time: ~5 minutes

DataAgent and AnalysisAgent fly in formation, coordinated by a LangGraph supervisor. Metaflow wraps the whole operation as a FlowSpec — each agent role gets its own isolated, lockable environment. A dependency conflict between Polars and LangGraph is structurally impossible.

start → ingest (polars, scikit-learn)
      → analyze (openai, langgraph)
      → join → end

Tools: LangGraph, Metaflow 2.18+, FlowSpec

---

04 — Deployment and Inference: Mission Control Endpoints

Three LLM targets, one agent interface, zero code changes. Time: ~3 minutes

The agents from Module 03 call an LLM via the openai client. That client points at a URL. This module shows what lives at the URL — and proves that swapping it is a one-line env var change.

Target	base_url	Best for
AI Navigator	http://localhost:8080/v1	Local dev, no API key
vLLM (self-hosted)	http://server:8000/v1	Production GPU, full control
Anaconda Platform	$MODEL_SERVER_BASE_URL	Enterprise, governed, AIBOM

Anaconda Platform adds: Model Catalog with HellaSwag/WinoGrande/TruthfulQA benchmarks, downloadable AIBOM (CycloneDX JSON), Responsible AI scoring via Gray Swan, Model Governance for org-wide policy.

Supporting docs in deploy/: ai-navigator.md, vllm.md, anaconda-platform.md

Tools: vLLM, Anaconda Platform Model Servers, inference_client.py

---

05 — GPU-Accelerated Intelligence: Afterburners

Same pipeline. NVIDIA iron. 47× faster feature engineering. Time: UNKNOWN - experimental

The Module 03 flow gets a CUDA upgrade. compute_features moves from Polars CPU rolling windows to a CUDA Python 1.0 kernel. The LLM switches from Claude Haiku to Nemotron 3 Nano on vLLM via Brev. The agents don't know any of this happened.

Module 03                    Module 05
─────────────────────────    ────────────────────────────────
@conda per step   same  →    + nvidia channel, cuda-python
ingestion.py      same  →    same functions
Claude Haiku            →    Nemotron 3 Nano (BF16) on vLLM
CPU rolling windows     →    CUDA Python kernel
no sandbox              →    NemoClaw security layer (alpha)

What each NVIDIA tool actually is (not Python imports):

• Brev — CLI to provision an L40S in ~3 minutes: brev create
• CUDA Python 1.0 — from cuda.core.experimental import Device — direct kernel access
• Nemotron — HuggingFace model, served via vLLM, called via openai client
• NemoClaw — TypeScript CLI + Python blueprint, sandboxed agent runtime (alpha)

conda-pypi note: vLLM is PyPI-only. The pip: section in environment.yml is the current pragmatic path. conda-pypi (experimental, Q1 2026) is the safer long-term approach — converts wheels to .conda format, integrates with the solver. Track: conda/conda-pypi

Benchmarks (50 light curves): 47.5× feature engineering speedup · 4.8× end-to-end

Tools: Brev, CUDA Python 1.0, vLLM, Nemotron 3 Nano (BF16), NemoClaw

---

06 — App Architecture: Mission Hardening

The pipeline that keeps flying when things go wrong. Time: ~5-7 minutes

Module 03's flow works on good data with a responsive LLM. This module adds four additive patterns that keep it running in production:

Pattern              Metaflow tool         What it solves
─────────────────    ──────────────────    ────────────────────────────────────────
Graceful degradation @catch                One bad target doesn't abort the mission
Eval-as-CI           evaluate step         Assertions run every execution, fail loud
Observability        @card                 HTML reports per target + per run
Agent memory         DuckDB vector store   Past results injected as context at inference

The evaluate step runs assertion functions from evals/assertions.py — plain Python, no Metaflow dependency, testable with pytest. Critical failures raise AssertionError. The @card on end is the single view you check after every production run.

The DuckDB memory store (from the vector DB comparison: pgvector / MongoDB Atlas / Neo4j / DuckDB — embedded, portable, conda-pack-able) gives agents memory across runs: past ValidationReport results retrieved by cosine similarity and injected into the system prompt.

Tools: LangGraph, Pydantic, DuckDB, Metaflow: FlowSpec, @catch, @card, @conda, @retry

---

07 — Mission-Critical Infrastructure: No Failures Tolerated"

Prove the environment is safe before it flies.

Supply chain security isn't a feature you add at the end. It's the infrastructure the pipeline runs on. Five layers, zero pipeline code changes:

Layer    Tool                               The question it answers
───────  ─────────────────────────────────  ─────────────────────────────────────────
Lock     conda-lockfiles                    Is this environment bit-for-bit reproducible?
Scan     anaconda-audit                     Does it contain known vulnerabilities?
Gate     Anaconda Platform policy filter    Did anything vulnerable get in upstream?
Pack     conda-pack                         Can we deploy without internet access?
Verify   AIBOM + SHA-256                    Is the model file what we think it is?

• anaconda-audit scan --name app-architecture — CVE scan against NVD/NIST, Anaconda-curated statuses (Active / Cleared / Mitigated / Disputed)
• P