Home/Blog/Labs 01
What we learn in the labs · Part 01

Your first app on an LLM in the cloud.

In the first workshop, each person builds a chatbot with memory and an agent that looks up orders for an online store. No GPU required. The model runs in NVIDIA's cloud and is called through an API. We ran the notebook end to end, and this is what happened, including what went wrong.

Technical content supported byNVIDIA
AuthorCarlos Lara, Chief Product Officer
PublishedNovember 1, 2026
Reading time8 minutes
ModelNemotron 3.5 Lightning
Run10.31.2026, build.nvidia.com
Step 1

Connecting takes three lines.

The notebook uses the openai library. Its API format became the industry standard. Here it simply points at NVIDIA's service. All you need is a free key from build.nvidia.com, which starts with nvapi-.

Cell that creates the client and confirms the connection to nvidia/nemotron-3.5-lightning-30b-a3b
The cell confirms the connection. The 120-second timeout matters: the free tier is sometimes very slow.
Step 2

The model thinks before it answers.

Nemotron 3.5 Lightning reasons before it responds. The reasoning arrives in a field separate from the answer. That is why the notebook streams from the very first call. Without streaming, people stare at a blank screen and assume it froze.

In this run the model thought in English and answered in Spanish. To say hello in one sentence, it wrote a five-step plan.

Step 2 output: the model's reasoning in English and the final answer Hola, ¿cómo estás?
First the reasoning, then the answer. The reasoning_budget parameter caps how much it can think.
What we learned

With no cap, one answer spent 1,582 tokens thinking and took 13 seconds. With reasoning_budget at 256 it dropped to 274 tokens and 5.7 seconds. We measured it in September, with the same question.

Step 3

The personality lives in the system prompt.

The same question goes to two bots. One is a patient teacher. The other is a terse engineer. Only the system instruction changes.

The engineer answered cleanly, in one sentence. The teacher's reasoning leaked into its answer: you can watch the model count sentences and fix a typo in a Spanish verb.

Two answers to What is an LLM?; the teacher's answer has the English reasoning mixed in
Unedited. This call does not stream and has a reasoning cap.
What we learned

With reasoning on, a short cap and no streaming, the thinking sometimes ends up inside the answer. In a real app, keep the two fields apart and validate what you show.

Step 5

The model has no memory.

This step fails on purpose. In the first turn you say your name is Ana and you work in logistics. In the second you ask for your name. Each call arrives on its own, so the model knows nothing about Ana. It introduced itself instead.

Turn 1 greets Ana; turn 2 answers Soy Nemotron without knowing who Ana is
In turn 2 the model answers "I am Nemotron". It does not remember turn 1.
Steps 6 and 7

Memory is a list.

The fix is to keep every turn in a list and send the whole list on each call. With that, the bot remembers. The function that does it also retries when the free tier returns an empty answer, takes too long, or asks you to slow down.

Chat with memory: the bot remembers the user is Ana and works in logistics
The dots are the model thinking. Now it remembers Ana, although it answered as if it were Ana.
Steps 8 to 10

Examples teach the format.

The task is to turn customer messages into one-line tickets: #order | reason | priority. A function checks the format and marks OK or X. You see the effect of the examples instead of guessing it.

Zero-shot: three X, the model writes long markdown tickets
No examples: three X. The model wrote long tickets with headings and bold text.
One-shot: two OK and one X
One example: two OK. Look at the third line: the cancellation had no order number and the model made up 1043.
Few-shot: three OK
Three examples: three OK.
What we learned

The validator checks the shape, not the content. The made-up ticket from the one-shot run passed as OK. A correct format does not guarantee a correct fact.

Step 11

An agent that uses a tool.

The agent gets the question "Has my order 1043 shipped, and when does it arrive?". It cannot see the store's database. It only sees one line describing the consultar_pedido tool. It writes what it wants to do, your code runs the tool and hands back the result.

The agent looks up order 1043 and answers in two steps
Two steps: look up, then answer. Generation stops before "Observación:" so the model cannot invent the tool's result.
Step 12

When a tool is missing, the agent guesses.

Now the question is "In how many days does my order 1043 arrive?". The agent has the delivery date. It does not know today's date.

It did not say so. It assumed today was the day the order shipped and answered "about 5 days". The right answer was 2.

The agent assumes today's date and answers 5 days, when the right answer is 2
The agent's second step shows the assumption: "assuming the current date is 2026-10-28".
Step 13

The tool corrects the model.

We registered a second tool, contar_hasta, which counts the days from today to a date. The model imagined a wrong date again in its reasoning. It did not matter: the tool returned the real date and the answer was 2 days.

With the contar_hasta tool, the agent correctly answers that the order arrives in 2 days
Giving the agent a new capability means adding one line to the HERRAMIENTAS dictionary.
What we learned

An agent without the fact it needs does not stop: it makes something up, confidently. The right tool turns an assumption into a fact. It is the same problem RAG solves in the next part.

In short

Four ideas to take with you.

  1. A model in the cloud is a remote function: you send text and get text back.
  2. The system prompt sets the personality. The history gives it memory.
  3. With examples, the model follows a format better. Validate the content too.
  4. With tools, the model asks for facts it does not have. Your code decides what runs.