Welcome to the comprehensive documentation for Pocket, a graph execution engine for building LLM workflows.
Perfect for most users who want to run workflows defined in YAML:
- Install Pocket CLI - Get up and running in minutes
- Getting Started Tutorial - Create your first workflow
- YAML Schema Reference - Define workflows in YAML
- Command Reference - All CLI commands
Example:
# Install via Homebrew
brew install agentstation/tap/pocket
# Run a workflow
pocket run workflow.yamlFor developers building Go applications:
- Library Getting Started - Build workflows in Go
- Embedding Guide - Integrate into your application
- API Reference - Complete API documentation
Example:
import "github.com/agentstation/pocket"
node := pocket.NewNode[string, string]("process",
pocket.WithExec(processFunc),
)Everything you need to use Pocket as a command-line tool.
- CLI Overview - Introduction to the CLI
- Installation - Installation methods
- Getting Started - First workflow tutorial
- Command Reference - All commands and options
- YAML Schema - Complete YAML reference
- Configuration - Config files and environment
- Plugin Management - Installing and using plugins
- Troubleshooting - Common issues and solutions
For embedding Pocket in your Go applications.
- Library Overview - Introduction to the Go library
- Getting Started - Build your first workflow
- API Reference - Complete API documentation
- Embedding Guide - Integration patterns
Understand the fundamental architecture of Pocket's graph execution engine.
- Architecture Overview - Graph-based workflow design
- Prep/Exec/Post Pattern - The three-phase lifecycle
- Node Interface Design - How nodes work
- Graph Composition - Building complex workflows
Documentation for all available node types.
- Node Types Overview - All node categories
- Built-in Nodes - 14 built-in node types
- Lua Scripting - Custom logic with Lua
- WebAssembly Plugins - Plugins in any language
Real-world workflow examples organized by complexity.
- Example Workflows - Catalog of examples
- Basic Workflows - Simple starting points
- Advanced Workflows - Complex patterns
- Real-World Examples - Production patterns
Step-by-step guides for specific topics.
- Type Safety Guide - Leveraging Go's type system
- State Management - Working with stores
- Error Handling - Building resilient workflows
- Testing Workflows - Testing best practices
Common patterns for building sophisticated workflows.
- Concurrency Patterns - Parallel execution
- Agent Patterns - Building LLM agents
- Workflow Patterns - Complex flows
- Batch Processing - Processing large datasets
Deep dives into advanced features.
- Middleware System - Hooks and lifecycle
- YAML Integration - Declarative workflows
- Performance Optimization - Optimization guide
- Custom Nodes - Creating custom nodes
For contributors and plugin developers.
- Plugin Development - Create plugins
- Contributing Guide - How to contribute
- Architecture - Internal design
- Go Style Guide - Code style guidelines
Detailed reference documentation.
- API Reference - Complete API documentation
- Node Reference - Auto-generated node reference
- Configuration Options - All config options
- Plugin System - Plugin architecture
- Start with CLI Installation
- Follow the Getting Started Tutorial
- Learn the YAML Schema
- Explore Workflow Examples
- Install Plugins for extended functionality
- Begin with Library Getting Started
- Understand Core Architecture
- Learn the Prep/Exec/Post Pattern
- Master Type Safety
- Study Embedding Patterns
- Read Plugin System Overview
- Choose your approach:
- Lua Scripts for simple logic
- WebAssembly for complex plugins
- Follow Plugin Development Guide
- See Plugin Examples
- Main README - Project overview
- GitHub Repository - Source code
- Issues - Report bugs
- Examples - Code examples
- pkg.go.dev - Go package docs
We welcome documentation improvements! If you find errors or have suggestions:
- Open an issue describing the improvement
- Submit a PR with your changes
- Ensure examples are tested and working
See our Contributing Guide for more details.