| name | pocketbase |
| description | Comprehensive PocketBase development and deployment skill providing setup guides, schema templates, security patterns, API examples, data management scripts, and real-time integration patterns for building backend services with PocketBase. |
PocketBase Skill - Comprehensive Reference
Overview
This skill provides modular, searchable documentation for PocketBase development. Use the table of contents below to navigate to specific topics. The researcher-pocketbase agent can efficiently search and extract information from the reference files based on your query. PocketBase is an open source backend in 1 file. It provides a realtime database, authentication, file storage, an admin dashboard and is extendable to much more.
Quick Navigation
For Newcomers
→ Start with Getting Started for initial setup and basic concepts
→ Review Collections to understand data modeling
→ See Authentication for user management
→ Check API Rules & Filters for security
For Implementation
→ Browse Schema Templates for pre-built data models
→ Use Records API for CRUD operations
→ Implement Real-time for live updates
→ Follow Files Handling for file uploads
→ Read Working with Relations for data relationships
For Production
→ See Going to Production for deployment
→ Review Security Rules for access control
→ Check API Reference for complete API documentation
For Advanced Users
→ Explore Go Extensions for custom functionality
→ Study Event Hooks for automation
→ Learn Database Operations for advanced queries
→ Plan data migrations with Data Migration Workflows
Table of Contents
Core Concepts & Setup
| Topic | Description | When to Use |
|---|
| Getting Started | Initial setup, quick start, basic concepts | First time using PocketBase, initial configuration |
| CLI Commands | PocketBase CLI, serve, migrate, admin, superuser | Development workflow, server management, migrations |
| Collections | Collection types, schema design, rules, indexes | Designing data models, creating collections |
| Authentication | User registration, login, OAuth2, JWT tokens | Building user accounts, login systems |
| API Rules & Filters | Security rules, filtering, sorting, query optimization | Controlling data access, writing efficient queries |
| Files Handling | File uploads, thumbnails, CDN, security | Managing file uploads, image processing |
| Working with Relations | One-to-many, many-to-many, data relationships | Building complex data models, linking collections |
| Going to Production | Deployment, security hardening, monitoring, backups | Moving from development to production |
| Data Migration Workflows | Import/export strategies, scripts, and tooling | Planning and executing data migrations |
API Reference
| Endpoint | Description | Reference File |
|---|
| Records API | CRUD operations, pagination, filtering, batch operations | api_records.md |
| Realtime API | WebSocket subscriptions, live updates, event handling | api_realtime.md |
| Files API | File uploads, downloads, thumbnails, access control | api_files.md |
| Collections API | Manage collections, schemas, rules, indexes | api_collections.md |
| Settings API | App configuration, CORS, SMTP, general settings | api_settings.md |
| Logs API | Access logs, authentication logs, request logs | api_logs.md |
| Crons API | Background jobs, scheduled tasks, automation | api_crons.md |
| Backups API | Database backups, data export, disaster recovery | api_backups.md |
| Health API | System health, metrics, performance monitoring | api_health.md |
SDKs & Development Tools
| SDK | Description | Reference File |
|---|
| JavaScript SDK | Frontend integration, React, Vue, vanilla JS | js_sdk.md |
| Go SDK | Server-side integration, custom apps | go_sdk.md |
| Dart SDK | Mobile app integration (Flutter, etc.) | dart_sdk.md |
Go Extension Framework
| Topic | Description | Reference File |
|---|
| Go Overview | Project structure, basic concepts, getting started | go_overview.md |
| Event Hooks | Before/After hooks, custom logic, automation | go_event_hooks.md |
| Routing | Custom API endpoints, middleware, handlers | go_routing.md |
| Database | Query builder, transactions, advanced queries | go_database.md |
| Records | Record CRUD, validation, custom fields | go_records.md |
| Collections | Dynamic schemas, collection management | go_collections.md |
| Migrations | Schema changes, version control, deployment | go_migrations.md |
| Jobs & Scheduling | Background tasks, cron jobs, queues | go_jobs_scheduling.md |
| Sending Emails | SMTP configuration, templated emails | go_sending_emails.md |
| Rendering Templates | HTML templates, email templates, PDFs | go_rendering_templates.md |
| Console Commands | CLI commands, migrations, maintenance | go_console_commands.md |
| Realtime | Custom realtime logic, event handling | go_realtime.md |
| File System | File storage, CDN, external storage providers | go_filesystem.md |
| Logging | Structured logging, monitoring, debugging | go_logging.md |
| Testing | Unit tests, integration tests, test helpers | go_testing.md |
| Miscellaneous | Advanced features, utilities, tips | go_miscellaneous.md |
| Record Proxy | Dynamic record behavior, computed fields | go_record_proxy.md |
Reference Materials
| File | Description | Contents |
|---|
| Security Rules | Comprehensive security patterns | Owner-based access, role-based access, API rules |
| Schema Templates | Pre-built data models | Blog, E-commerce, Social Network, Forums, Task Management |
| API Reference | Complete API documentation | All endpoints, parameters, examples |
Development Resources
| Resource | Description | Location |
|---|
| Scripts | Executable utilities for development | scripts/ directory |
| Assets | Templates and configuration files | assets/ directory |
| Docker Config | Production-ready Docker setup | assets/docker-compose.yml |
| Caddy Config | Automatic HTTPS configuration | assets/Caddyfile |
| Frontend Template | HTML/JS integration example | assets/frontend-template.html |
| Collection Schema | Blank collection template | assets/collection-schema-template.json |
How to Use This Skill
For the Researcher-Pocketbase Agent
This skill is designed for efficient information retrieval. When researching PocketBase topics:
- Start with Core Concepts - Review
references/core/ for foundational knowledge
- Find API Details - Use
references/api/ for specific API endpoints
- Look up Go Extensions - Check
references/go/ for custom functionality
- Find Examples - Reference
references/templates/ and references/security_rules.md
Topic Categories
Setup & Configuration
- Getting Started → Initial setup and basic concepts
- CLI Commands → Development workflow, server management
- Going to Production → Deployment and production configuration
- Collections → Data model design
Data Management
- Collections → Creating and managing collections
- Working with Relations → Linking data across collections
- Files Handling → File uploads and storage
Security & Access Control
- Authentication → User management
- API Rules & Filters → Access control and queries
- Security Rules → Comprehensive security patterns
API Integration
- Records API → CRUD operations
- Realtime API → Live updates
- Files API → File management
- Other API endpoints → Settings, logs, backups, health
Frontend Development
- JavaScript SDK → Web integration
- Schema Templates → Pre-built data models
- Frontend Template → Integration example
Backend Development
- Go SDK → Server-side integration
- Go Extensions → Custom functionality
- Console Commands → CLI tools
Common Query Patterns
"How do I..."
- How do I create a blog? → Schema Templates
- How do I set up authentication? → Authentication
- How do I upload files? → Files Handling
- How do I add real-time updates? → Realtime API
"How to configure..."
- How to configure production? → Going to Production
- How to set up security rules? → API Rules & Filters, Security Rules
- How to create custom endpoints? → Go Routing
- How to schedule jobs? → Jobs & Scheduling
"What's the best way to..."
- What's the best way to structure my data? → Collections, Working with Relations
- What's the best way to secure my API? → API Rules & Filters, Security Rules
- What's the best way to optimize queries? → API Rules & Filters
- What's the best way to handle files? → Files Handling
"Error:..."
- CORS errors → Authentication, Going to Production
- Permission errors → API Rules & Filters, Security Rules
- File upload errors → Files Handling
- Slow queries → API Rules & Filters (indexing)
"Need to implement..."
- Need user roles? → Authentication, Security Rules
- Need file uploads? → Files Handling
- Need real-time chat? → Realtime API
- Need custom logic? → Go Extensions
Quick Reference Index
Common Tasks
Code Examples
Best Practices
File Locations
Core Documentation
/references/core/
├── getting_started.md # Initial setup and concepts
├── cli_commands.md # CLI commands and server management
├── collections.md # Data modeling and collections
├── authentication.md # User management
├── api_rules_filters.md # Security and querying
├── files_handling.md # File uploads and storage
├── working_with_relations.md # Data relationships
└── going_to_production.md # Deployment guide
API Reference
/references/api/
├── api_records.md # CRUD operations
├── api_realtime.md # WebSocket subscriptions
├── api_files.md # File management
├── api_collections.md # Collection operations
├── api_settings.md # App configuration
├── api_logs.md # Logging
├── api_crons.md # Background jobs
├── api_backups.md # Backups
└── api_health.md # Health checks
Go Extensions
/references/go/
├── go_overview.md # Getting started
├── go_event_hooks.md # Event system
├── go_routing.md # Custom routes
├── go_database.md # Database operations
├── go_records.md # Record management
├── go_collections.md # Collection management
├── go_migrations.md # Schema changes
├── go_jobs_scheduling.md # Background tasks
├── go_sending_emails.md # Email integration
├── go_rendering_templates.md # Templates
├── go_console_commands.md # CLI tools
├── go_realtime.md # Custom realtime
├── go_filesystem.md # File storage
├── go_logging.md # Logging
├── go_testing.md # Testing
├── go_miscellaneous.md # Advanced topics
└── go_record_proxy.md # Dynamic behavior
SDKs
/references/sdk/
├── js_sdk.md # JavaScript
├── go_sdk.md # Go
└── dart_sdk.md # Dart
Templates & Security
/references/
├── security_rules.md # Security patterns
├── templates/
│ └── schema_templates.md # Pre-built schemas
└── api_reference.md # Complete API docs
Information Architecture
This skill follows a modular architecture designed for progressive disclosure:
- Quick Access - SKILL.md provides immediate overview and navigation
- Focused Topics - Each reference file covers one specific area
- Cross-References - Files link to related topics
- Examples First - Practical code examples in each file
- Searchable - Clear titles and descriptions for quick lookup
When to Use Each Section
references/core/
- New users starting with PocketBase
- Understanding fundamental concepts
- Basic implementation tasks
references/api/
- Implementing specific API features
- Looking up endpoint details
- API integration examples
references/go/
- Building custom PocketBase extensions
- Advanced functionality
- Custom business logic
references/sdk/
- Frontend or mobile integration
- SDK-specific features
- Language-specific examples
references/security_rules.md
- Complex access control scenarios
- Security best practices
- Multi-tenant applications
references/templates/
- Rapid prototyping
- Common application patterns
- Pre-built data models
Notes for Researchers
This skill contains over 30 reference files covering all aspects of PocketBase development. The researcher-pocketbase agent should:
- Match queries to appropriate topic areas
- Extract specific information from relevant files
- Provide comprehensive answers using multiple references
- Suggest related topics for further reading
- Identify best practices and common pitfalls
Each reference file is self-contained with examples, explanations, and best practices. Use the table of contents above to quickly navigate to the most relevant information for any PocketBase-related question.
