Draw the flow.Get the code.
RAGorbit is a canvas for RAG and agentic strategies. Connect blocks — loaders, a vector store, your services, guardrails — and it generates a real Python project: LangGraph and LangChain, with mock services and tests so it runs the first day.
The generated project is ordinary code. It runs without RAGorbit, and you own it the moment it lands on disk.
# one file, any python3 — no pip, no venv
$ curl -fsSL https://slothlabs.org/install/ragorbit | sh
$ ragorbit generate flow.json --out ./my-bot
✓ app/ · nodes.py + graph.py (LangGraph)
✓ mocks/ · fixtures and mock services
✓ tests/ · end-to-end, already green
$ cd my-bot && python3 -m unittest discover -s tests
OK — it works before you write a lineOpen source · MIT · 53 node types · 10 industry templates · LangGraph · LangChain
A prototype you have to rewrite wasn't a prototype.
Designing a RAG or agentic system is mostly deciding: which store, which retrieval, where the rules live, what a human has to approve. The tooling should make those decisions cheap to try — not make them expensive to keep.
Visual builders trap your work
You wire up a flow in a low-code tool and the result only runs inside that tool. To go to production you rewrite it by hand — so the prototype was a drawing, not a head start.
A blank repo is a bad brief
Starting from scratch means a week of plumbing — loaders, a store, retries, a test harness — before anyone can see whether the idea works at all.
Nothing runs until everything runs
No API key, no database, no access to that internal service — so the whole pipeline sits dead. The demo waits on credentials instead of on the design.
A canvas, a JSON,
and a repo you keep.
Canvas
drag & drop, typed ports
Flow IR
portable JSON · the source of truth
Codegen
one emitter per node type
Artifact
app/ · mocks/ · tests/ · Dockerfile
Draw it, or start from a template
Drag blocks onto the canvas and connect them. Ports are typed, so a store cannot be wired to a prompt and the mistake is visible as you make it. Ten industry templates give you a working flow to modify instead of a blank page.
It saves as one portable JSON
The Flow IR is the source of truth — nodes, edges, config, the names of the secrets (never the values). It is plain JSON: diff it, review it in a PR, generate from it in CI. Nothing about it is proprietary.
Codegen produces a project you own
One function per node in app/nodes.py, the LangGraph wiring in app/graph.py, mock services, fixtures and end-to-end tests. Run it with mocks immediately; flip one environment variable to go real.
Generated code you'd have written anyway.
The test of a generator is whether you keep its output. Every feature here exists to make the answer yes.
The artifact is yours, not a runtime
No lock-inStandard Python: LangGraph and LangChain, one function per node, readable wiring. No SDK to install, no service to call home to, no format only the tool understands. Delete RAGorbit and nothing breaks.
It runs before it has credentials
Day oneEvery artifact ships mock services, fixtures and end-to-end tests. `python -m unittest` is green on a laptop with no network, no API key and no database. You demo the design, then wire the real thing.
It refuses to generate nonsense
Contract checks run before codegen: an agent with no tools, a store with no embeddings, a guardrail wrapping nothing, a missing secret. You get told what to connect instead of a project that fails at runtime.
53 node types, 13 categories
Loaders, chunkers, embeddings, vector stores and graph stores, hybrid retrieval and rerankers, agents, tools, guardrails, HITL, observability, multimodal, and the IO shapes for chat, batch and event workers.
Rules the model cannot overrule
Deterministic decisions stay deterministic: rule conditions are compiled to Python at generation time, so there is no eval in your artifact — and a rule whose inputs are missing raises instead of quietly deciding.
Mock and real, same shape
Each node has a mock behaviour and a real implementation with the same signature, so you can read them side by side. Promoting from mock to production is an environment variable, not a rewrite.
Zero dependencies, one file
The engine is pure standard library — catalog, validator, contracts, codegen, mock runtime. It ships as an 80 KB zipapp that runs on any python3. No install, no venv, nothing to resolve.
Extensible without touching the core
Adding a technology is three small pieces: a manifest, a code emitter and a mock behaviour. The registry discovers it, the palette shows it, the form builds itself from your JSON Schema.
A free course that teaches all of it
FreeTwelve modules, bilingual, every topic in three layers: the concept, the mechanism built from scratch in pure Python, then the production framework. Each topic anchored to a node and a template.
Start from a real system,
not an empty canvas.
Each template is a complete flow from a different industry, with a walkthrough of every block and why it is there. All ten validate, generate and pass their tests on every commit — so what you open is what runs.
Low-code gets you the demo.
The question is what happens next. If going to production means rewriting the flow by hand, the visual step was documentation. RAGorbit is built so the thing you drew is the thing you ship.
Learn the whole stack, not just this tool
RAGorbit has a full course behind it: twelve modules from zero to RAG, agents, MCP, multimodal, guardrails and deployment. Every topic in three layers — the concept, then the mechanism built by hand in pure Python, then the production framework. The from-scratch layer is the point: understand the mechanism and you can use any stack, including none of these.
Labs run in the browser. The from-scratch solutions need only the standard library, so you can do the entire course offline.
The catalog grows.
The contract does not change.
Adding a technology never touches the core, so new blocks land without breaking the flows you already drew.
The three deployment targets, generated for real
chat-service, batch and event-worker all produce a working artifact: 53 node types, contract checks, mocks and tests, Docker, and a Cloud Run path for the chat target.
More stores and rerankers in the catalog
Qdrant, Weaviate and Neo4j as first-class nodes, plus hosted rerankers. Each is a manifest, an emitter and a mock behaviour — the extension path is the same one you would use.
Round-trip: import an existing project back to a flow
Read a generated artifact and recover its Flow IR, so a project that drifted from its diagram can be edited on the canvas again instead of being frozen at generation time.
Draw the system.
Keep the code.
One file, any Python 3.10+. Free and open source — always.
# one file, no install
$ curl -fsSL https://slothlabs.org/install/ragorbit | sh
# or with Homebrew
$ brew install slothlabsorg/tap/ragorbit
# or with pipx
$ pipx install ragorbitPython 3.10+ · zero dependencies · LangGraph · LangChain · 53 node types · MIT license