For TypeScript developers who need to ship LLM features in Node.js, edge and browser runtimes with typed structured outputs, streaming UIs, tool calling and real tests.
The curriculum is being prepared and reviewed. Enrollment is not open yet.
About this course
TypeScript is now one of the main languages for shipping AI features, because the same code can run on a Node.js server, in a serverless function, on an edge runtime and in the browser. That flexibility comes with choices: official provider SDKs or a provider-neutral layer, server or edge, a hosted API or a model running in-process.
This course works through those choices with current tools. You will use the official SDKs (openai, @anthropic-ai/sdk and @google/genai), then the Vercel AI SDK (the ai package with @ai-sdk providers) for streaming text, typed objects and tool calls across vendors. You will define schemas once with Zod and get typed, validated outputs, stream tokens to React and other UIs, and control concurrency, cancellation and retries with AbortController and p-limit. You will compare agent layers (LangChain.js, Mastra, the OpenAI Agents SDK and the Claude Agent SDK) and expose or consume tools over the Model Context Protocol. For local and private work you will run models in-process with Transformers.js and node-llama-cpp or call Ollama. Finally you will test with Vitest and MSW, and package and deploy to Node.js LTS, Bun, Deno and Cloudflare Workers. Package versions are stated as of October 2026 (for example ai v7, zod v4, Node.js 24 as Active LTS).
What you will be able to do
Call OpenAI, Anthropic and Gemini from TypeScript with their official SDKs and explain when a provider-neutral layer such as the Vercel AI SDK is the better choice
Define Zod schemas that produce typed, validated structured outputs and handle validation failures deliberately
Stream model output from a server route to a browser UI with cancellation, backpressure and error states handled
Implement tool calling and connect a TypeScript application to Model Context Protocol servers
Run an embedding or small generative model in-process with Transformers.js or node-llama-cpp and judge when that beats a hosted API
Write deterministic unit and integration tests for LLM code with Vitest and MSW, plus a small evaluation suite
Package and deploy an AI feature to Node.js, serverless and edge runtimes with secrets, rate limits and observability in place
Syllabus
6 modules · 19 lessons · about 14 hours
1
Module 1: Official SDKs and the Provider-neutral Layer
What the vendor SDKs give you, and what the Vercel AI SDK adds on top.3 lessons
openai, @anthropic-ai/sdk and @google/genai: clients, errors, retries and the Responses and Messages APIs
The Vercel AI SDK: generateText, streamText and swapping providers
Configuration, secrets and per-request cost tracking in a Node.js service
2
Module 2: Typed Structured Outputs and Tools
Using the type system to make model output safe to consume.4 lessons
Zod schemas as the single source of truth for prompts, outputs and validation
Structured object generation, partial objects and repair strategies
Tool calling with typed parameters and multi-step tool loops
Model Context Protocol in TypeScript: building and consuming servers with @modelcontextprotocol/sdk
3
Module 3: Streaming and Concurrency
Async patterns that keep AI features responsive and within rate limits.3 lessons
Streaming to the browser: server-sent events, UI message streams and React hooks
Cancellation with AbortController, timeouts and backpressure
Bounded parallelism with p-limit, batching and rate-limit handling
4
Module 4: Agents and Frameworks
When to use an agent framework in TypeScript and how the main options differ.3 lessons
LangChain.js and Mastra: chains, workflows and memory
OpenAI Agents SDK and Claude Agent SDK for TypeScript
Choosing between plain SDK code and a framework
5
Module 5: Local and In-process Models
Running models next to your code for privacy, cost and offline use.3 lessons
Transformers.js in Node.js and the browser: embeddings, classification and WebGPU
node-llama-cpp and Ollama: local generative models with JSON-schema grammars
Workers AI and edge inference trade-offs
6
Module 6: Testing, Packaging and Deployment
Shipping AI TypeScript code with the same discipline as the rest of the codebase.3 lessons
Vitest and MSW: mocking provider APIs and recording fixtures
Evaluation suites in CI: golden sets, graders and regression gates
Deploying to Node.js LTS, Bun, Deno and edge runtimes: bundling, cold starts and observability
Exam and certificate
The exam unlocks once you have completed every lesson. It draws 20 questions from a larger bank, spread across the modules, with the answer options shuffled for each attempt. You have 40 minutes and need 80% to pass. After a failed attempt you can try again after 24 hours, up to 3 attempts in total. Feedback is given per module, never as the answer key.
Passing earns a certificate of completion and assessment from the Wirewalk Institute of AI with a unique ID that anyone can check at institute.wirewalk.com/verify. It is not an accredited qualification or a vendor certification. How certification works.
The Wirewalk Institute of AI is independent. This course teaches publicly documented products and is not affiliated with or endorsed by OpenAI, Anthropic, Google (Gemini), Vercel (AI SDK), LangChain, Mastra, Ollama, Hugging Face (Transformers.js), Cloudflare (Workers AI), or Model Context Protocol. Product and company names are trademarks of their respective owners.
A free, one-hour, hands-on start built on one realistic job: sorting a property manager's 1,150 monthly maintenance requests. You get an API key the safe way, make real calls with curl and an official Python SDK, run them over forty work orders, read stop reasons, usage and errors, estimate the monthly cost, and decide whether the script is ready. Exercises run on your own provider account for well under a dollar.
A code-first course on integrating LLMs into Python the way production code needs it: uv projects and secrets, the OpenAI, Anthropic and Google GenAI SDKs side by side, async concurrency and streaming, Pydantic structured outputs and tools, retries, local models, embeddings and RAG, FastAPI and pandas integration, testing and evals with pytest, observability, cost tracking and deployment.
Call OpenAI, Anthropic, Gemini and local Ollama models from Perl with real CPAN modules, add streaming, concurrency and validated JSON output to text pipelines, and use AI coding assistants to modernize legacy Perl behind characterization tests.