Learn 9router - Pre-Requisites Skill & Setup Environment

#Introduction

Welcome to the Learn 9router series! This series will take you through mastering 9router — the AI routing gateway that manages, directs, and optimizes request traffic to various LLM providers — from conceptual foundations all the way to production-grade patterns. There are 23 episodes in total, arranged into six phases, starting from pre-requisites all the way to production hardening.

But before writing your first configuration file, there are several foundational skills and tools you must have. Why are these prerequisites important? Because 9router is a gateway — it stands between clients and LLM providers, receiving HTTP requests, making routing decisions, then forwarding traffic to the most appropriate model. If you don't yet understand how an HTTP conversation works, or how to read a YAML file, 9router configuration will feel like a mantra that sometimes works and sometimes doesn't.

Imagine wanting to become an airport traffic controller without understanding flight maps and communication protocols. No matter how capable the control tower — and 9router is an extremely capable control tower — it's still hard to direct aircraft without understanding the routes. Episode 0 is your roadmap: we'll prepare the foundational skills, make sure the tools are installed, then complete the LLM provider credentials that will accompany you throughout the series.

#Foundational Skills You Must Master

#AI Routing and Model Selection Basics

AI routing is the practice of deciding which AI model handles a given request. Every request has different needs: some need quick, cheap answers, some need deep reasoning, and some need image analysis or embeddings. 9router reads the request, then selects a model based on criteria such as cost, latency, quality, and business policy.

Model selection is not about picking "the best model", but about picking the model most appropriate for the request context. Sometimes an expensive large model is the wrong choice for a trivial question, and vice versa. From now on, get used to thinking in trade-offs: what you give up (cost, latency) for what you gain (quality, accuracy).

#HTTP/REST APIs, Webhooks, and the Request/Response Lifecycle

9router is an HTTP service. All traffic flows in and out over the HTTP protocol, so understanding it is a mandatory foundation. Understand the basic shape of the conversation: a request contains a method, path, headers, and sometimes a body; a response contains a status code, headers, and a body.

Also learn the five status code classes: 2xx success, 3xx redirect, 4xx client error (including 429 Too Many Requests during rate limiting), and 5xx server error. The last one matters too, because 9router maps errors from LLM providers to the appropriate status codes.

Beyond request/response, understand webhooks: a callback mechanism where the server sends an HTTP request back to the client when an event occurs. In the 9router context, webhooks are used for example for streaming completions, status notifications, or syncing results to a downstream service.

#JSON, YAML, CLI, and Git Workflows

9router configuration is written in YAML, while requests and responses between services are almost always JSON. You must be comfortable reading and writing both — including remembering that YAML is sensitive to indentation, and that numbers like 0123 can be misinterpreted without quoting.

Then there's the CLI: all 9router operations — project initialization, configuration validation, running a local server, and managing routes — happen through the terminal. Finally, Git workflows: because route config is code, it must be version-controlled, reviewed via pull request, and rolled back when something goes wrong. Note that the YAML format is an ideal baseline for diffing between versions.

#Observability Basics: Metrics, Logs, Tracing

An AI gateway without observability is pure guesswork. There are three pillars you must know:

All three will be covered in depth in episode 7, but from now on get used to reading numbers like latency percentiles and success rates. Prometheus for metrics, a log aggregator for logs, and an OpenTelemetry-based tracing tool for distributed traces are tools you'll encounter often.

#Software You Need to Prepare

#Access to the 9router Platform or a Local Emulator

There are two ways to start playing with 9router. First, use the hosted platform — log in to the dashboard, create a workspace, and use the provided endpoints. Second, and most recommended for learning, run a local emulator whose behavior is identical to the production platform. The local emulator is available as a Docker image:

docker run -d --name 9router-local -p 8080:8080 \
  -e 9ROUTER_MODE=emulator \
  ghcr.io/9router/9router:latest

The command above runs the emulator on port 8080. Make sure Docker is running and port 8080 doesn't collide with another service.

#LLM Provider Credentials

9router needs to call LLM providers on your behalf, which requires an API key. Prepare credentials for at least one provider — OpenAI, Azure OpenAI, or Anthropic. Never put a key directly in a configuration file; use environment variables as in the example below:

export OPENAI_API_KEY="sk-..."
export ANTHROPIC_API_KEY="sk-ant-..."
export AZURE_OPENAI_API_KEY="..."

Important note: the credential values above are examples only. Real keys are secret, so store them in a secret manager or a dot-env file that is never committed to git.

#Editor and Monitoring Tools

For the editor, VS Code with JSON and YAML extensions is more than enough — the auto-format and schema validation features will save you from indentation errors. For monitoring, set up Prometheus and Grafana to visualize metrics, or use your observability stack of choice. Not mandatory in this episode, but good to install early.

#Verifying the Environment

Before moving on to the next episode, make sure all the core tools are installed by running a single verification line:

node --version
npm --version
git --version
docker --version
curl --version

All the commands above must return a version number, not command not found. If one is missing, install it using your package manager — for example npm install -g @9router/cli for the 9router CLI or sudo apt install docker.io for Docker on Debian-based distros.

#Episode 0 Checklist Summary

• Understand the concept of AI routing and trade-off-based model selection.
• Be comfortable with HTTP/REST, webhooks, and the request/response lifecycle.
• Be able to read and write JSON and YAML, and be comfortable with the CLI and Git.
• Know the three observability pillars: metrics, logs, and tracing.
• The 9router local emulator is running on localhost:8080.
• LLM provider credentials are stored as environment variables.
• Node.js, npm, git, Docker, and curl are verified.

#Conclusion

In episode 0 you've laid the foundation for the entire series: understanding the basics of AI routing, HTTP/REST and webhooks, JSON/YAML, CLI and Git, and observability; making sure the local emulator and LLM provider credentials are ready; and verifying the core tooling in your environment.

Key takeaways:

• AI routing is about choosing the model most appropriate for the request context, not the most expensive one.
• 9router is an HTTP service — master request/response, status codes, and webhooks.
• Configuration is written in YAML, traffic flows in JSON, and the whole lifecycle is managed through Git.
• Without metrics, logs, and tracing, an AI gateway runs in the dark.
• Verify your tooling: Node.js, npm, git, Docker, curl, plus provider credentials as environment variables.

In the next episode, episode 1, we'll discuss the history, background, and why the world needs an AI routing gateway — from the evolution of classic load balancers, comparisons of traditional API gateways with service mesh, to real-world use cases of prompt routing and multi-model orchestration. Make sure your environment is ready, because the Learn 9router journey has just begun!