Prerequisite map

You do not need to finish complete courses in Python, frontend development, or distributed systems before reading nanobot. This section follows a learn-just-enough approach: fill only the gaps that the source-reading path actually depends on.

Minimum starting point

Before beginning the core path, you should be able to:

• run Python commands and read a traceback;
• understand functions, classes, inheritance, dataclass, and type annotations;
• explain the basic roles of async def, await, Task, Queue, and Lock;
• read JSON, JSONL, and simple configuration;
• understand system, user, assistant, and tool messages in an LLM conversation;
• recognize that a model may return a Tool Call instead of final text;
• search for a symbol with rg and run one pytest file.

If any item is unfamiliar, read the matching “minimum requirement” lesson in this section. Do not expand the prerequisite scope unnecessarily.

Required depth by topic

Topic	Required depth	Recommended material
Python	Read classes, exceptions, context managers, abstract base classes, dataclasses, and type annotations	Python fundamentals
asyncio	Understand coroutines, Tasks, Queues, Locks, cancellation, and timeouts; event-loop internals are not required	Python and asyncio minimum
JSON and JSONL	Distinguish JSON objects, arrays, and line-delimited records; understand schema validation	JSON learning path
LLM APIs	Understand the request lifecycle, messages, streaming, errors, and usage	LLM API integration
Tool calling	Understand tool schemas, call IDs, argument validation, and tool-result reinsertion	Tool calling
Context engineering	Understand context windows, history, trimming, summarization, and trust boundaries	Context engineering
Agent loop	Understand the basic observation-decision-action-feedback-termination loop	Agent core
Testing and debugging	Run one test, read assertions and mocks; mastery of a full testing framework is not required	Source reading and debugging minimum
Security	Know least privilege, prompt injection, tool overreach, and untrusted input	AI safety
MCP	Needed only when you study MCP integration; the core turn does not depend on it	MCP architecture and roles
React/TypeScript	Basic reading ability is needed only for a deeper WebUI study	Not a core prerequisite

Dependency map

flowchart LR
    PY["Python fundamentals"] --> ASYNC["Minimum asyncio knowledge"]
    JSON["JSON / JSONL"] --> API["LLM APIs"]
    API --> TC["Tool calling"]
    TC --> LOOP["Agent loop"]
    CTX["Context engineering"] --> LOOP
    ASYNC --> LOOP
    LOOP --> NB["nanobot core source"]
    TEST["pytest and source search"] --> NB
    SEC["Security fundamentals"] --> EXT["Extension development"]
    NB --> EXT
    MCP["MCP fundamentals"] --> EXT

Topics you can learn on demand

The following subjects should not block you from starting:

• advanced Pydantic features;
• the complete aiohttp API;
• React state management;
• WebSocket protocol details;
• Python packaging and entry points;
• Linux namespaces or bubblewrap;
• provider-specific protocol differences.

When you first encounter one, understand only what it does in the current call chain. Go deeper when you are ready to modify that module.

Self-check

If you can answer these five questions, you are ready for Runtime and Source Map:

1. Why can await not simply be omitted?
2. What problem does asyncio.Queue solve that a plain list does not?
3. After a model returns a Tool Call, why is the tool result not automatically the final response?
4. Why might Session history not enter the next model request unchanged?
5. When a pytest test fails, how do you locate the function under test and its callers?

Not knowing an answer does not prevent progress. Read the three minimum-requirement lessons in this section, then return to the questions.

Next steps

1. Python and asyncio minimum
2. LLM messages, streaming, and tool calling
3. Source reading and debugging minimum