> For the complete documentation index, see [llms.txt](https://jig.gitbook.io/sley/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://jig.gitbook.io/sley/examples/python.md).
# Python examples
Browse complete Python projects by learning goal, Sley mechanism, and cognitive complexity.
Do not choose by ambition. Choose the smallest project that answers your next question, run it, and change one behavior. Complexity estimates cognitive load, not quality; lower is usually the more useful starting point.
## Start here
| Project | What it teaches | Sley mechanisms | Complexity |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------- | ------------------------------- | ---------: |
| Sley Hello World
Read the lesson
| Create a node, use shared state, and finish an ordinary leaf. | `node`, `state`, `run` | 2.5 |
| Retry and Recovery
Read the lesson
| Retry a complete handler and recover locally after attempts fail. | `retry`, `recover`, `Failure` | 3 |
| Text Converter Flow
Read the lesson
| Connect a readable two-node cycle and deliberately hard-end one path. | `link`, `Flow`, `end` | 4 |
| Shared Run State
Read the lesson
| Share durable facts between handlers through run state. | `state`, `link`, `run` | 4 |
| Article Writing Workflow
Read the lesson
| Model a three-step application workflow as explicit topology. | `node`, `link`, `Flow` | 6.5 |
| Async Recipe Finder
Read the lesson
| Await ordinary service I/O inside an async handler. | `async handler`, `state`, `run` | 4.5 |
## Branch, batch, and combine
| Project | What it teaches | Sley mechanisms | Complexity |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------- | -------------------------------------- | ---------: |
| Sequential Batch Translation
Read the lesson
| Dispatch repeated work while the Flow admits one branch at a time. | `emit`, `input`, `end` | 4 |
| Combine CSV Chunks
Read the lesson
| Publish chunk statistics and combine them after every branch settles. | `emit`, `end`, `combine` | 4.5 |
| Parallel Batch Translation
Read the lesson
| Run independent translation branches with local concurrency. | `emit`, `input`, `concurrency` | 5 |
| Reusing a Flow for Batch Work
Read the lesson
| Reuse a nested Flow as one branch worker. | `nested Flow`, `emit`, `end` | 6 |
| Sequential and Parallel Nested Flows
Read the lesson
| Compare sequential and concurrent nested scopes. | `nested Flow`, `concurrency`, `end` | 7 |
| Majority Vote
Read the lesson
| Collect several independent answers and choose a majority once. | `emit`, `end`, `combine` | 6 |
| Blind Best-of-N Judge
Read the lesson
| Generate distinct candidates and select through blind pairwise judging. | `emit`, `end`, `combine` | 9 |
| Resume Qualification with Map/Reduce
Read the lesson
| Keep Map and Reduce visible as application nodes. | `emit`, `end`, `combine` | 8 |
| Nested Batch Flow Example
Read the lesson
| Coordinate two levels of scoped fan-out and joining. | `nested Flow`, `end`, `combine` | 9.5 |
| Recovering a Partially Completed Batch
Read the lesson
| Recover a failed batch while preserving settled branch results. | `ScopeFailure`, `terminals`, `recover` | 6 |
## Agents and reasoning
| Project | What it teaches | Sley mechanisms | Complexity |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- | ------------------------------------------- | ---------: |
| Research Agent
Read the lesson
| Build a bounded search-and-answer loop from named decisions. | `emit`, `named link`, `max_activations` | 7 |
| Iterative Plan Refinement
Read the lesson
| Refine a compact plan through validated, bounded iterations. | `named link`, `max_activations`, `retry` | 5 |
| Orchestrator–Workers–Editor
Read the lesson
| Freeze a dynamic plan, fan sections out, and integrate the results. | `emit`, `input`, `combine` | 10 |
| Multi-Agent Taboo Game
Read the lesson
| Let independent Flows communicate through application queues. | `Flow`, `state`, `run` | 7 |
| Model Context Protocol Tools
Read the lesson
| Discover, validate, and invoke one MCP tool in a linear Flow. | `async handler`, `input`, `validation` | 8 |
| Evaluator–Optimizer Supervisor
Read the lesson
| Revise against structured independent feedback until approval or a stop. | `exits`, `nested Flow`, `max_activations` | 9 |
| Reference-Grounded Quality Loop
Read the lesson
| Compose benchmarked component loops, integration, and blind final judging. | `nested Flow`, `combine`, `max_activations` | 15 |
| External Task Protocol Adapter
Read the lesson
| Bridge a Flow to an application-owned JSON-RPC task boundary. | `run`, `state`, `max_activations` | 12 |
## Structured data and retrieval
| Project | What it teaches | Sley mechanisms | Complexity |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------- | ---------------------------------------- | ---------: |
| Structured Output
Read the lesson
| Parse and validate external structured output before committing state. | `state`, `retry`, `validation` | 3 |
| SQLite Tool
Read the lesson
| Keep a linear database workflow visible and testable. | `link`, `state`, `Flow` | 5 |
| Text to SQL
Read the lesson
| Inspect a schema, execute SQL, and route failures into a repair loop. | `emit`, `named link`, `max_activations` | 8 |
| Chat with Memory Retrieval
Read the lesson
| Combine recent state with retrieved history in a chat loop. | `state`, `named link`, `max_activations` | 7 |
| Retrieval-Augmented Generation
Read the lesson
| Separate offline indexing from an online retrieval Flow. | `nested Flow`, `emit`, `combine` | 9 |
## Tools and media
| Project | What it teaches | Sley mechanisms | Complexity |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------- | --------------------------------------- | ---------: |
| OpenAI Embeddings
Read the lesson
| Keep a provider call outside graph definition and inject it normally. | `node`, `state`, `run` | 3 |
| Web Search with Analysis
Read the lesson
| Search and analyze results through a small linear Flow. | `link`, `state`, `Flow` | 5 |
| PDF Vision Batch
Read the lesson
| Fan out PDF files and combine their page-level vision results. | `emit`, `end`, `combine` | 6 |
| Web Crawler with Content Analysis
Read the lesson
| Crawl once, fan pages out, and combine one report. | `emit`, `end`, `combine` | 9.5 |
| Stream an LLM Response
Read the lesson
| Stream provider output while application code owns interruption. | `node`, `state`, `run` | 4 |
| Voice Chat
Read the lesson
| Connect speech input, response, and playback in a visible loop. | `emit`, `named link`, `max_activations` | 7 |
| Flow Visualization
Read the lesson
| Render portable static topology from a compiled Flow. | `compile`, `describe`, `Flow` | 7 |
## Interactive applications
| Project | What it teaches | Sley mechanisms | Complexity |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------- | ------------------------------------------- | ---------: |
| Simple Chat
Read the lesson
| Repeat a one-node conversation until an ordinary leaf exit. | `named link`, `state`, `max_activations` | 3 |
| Travel Chat Guardrail
Read the lesson
| Validate user input before a model call and route rejection clearly. | `emit`, `named link`, `state` | 5 |
| Streamlit Human Review
Read the lesson
| Let a UI own staged human review around short Flow runs. | `run`, `state`, `Flow` | 4 |
| Web Human Review
Read the lesson
| Keep one short run alive while web requests deliver human feedback. | `async handler`, `state`, `max_activations` | 8 |
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.
Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:
```
GET https://jig.gitbook.io/sley/examples/python.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.