playbooks

home / skills / keboola / ai-kit / get-started

get-started skill

/plugins/component-developer/skills/get-started

This skill guides you to initialize Keboola Python components from scratch using the cookiecutter template and set up project structure.

npx playbooks add skill keboola/ai-kit --skill get-started

Review the files below or copy the command above to add this skill to your agents.

Files (2)
SKILL.md
2.2 KB
---
name: get-started
description: Guide for initializing and setting up new Keboola Python components using cookiecutter template. Use when starting a new component project from scratch.
model: sonnet
color: green
---

# Get Started with Keboola Component Development

This skill helps you initialize and set up new Keboola Python components from scratch using the official cookiecutter template.

## When to Use This Skill

- Starting a new Keboola component project
- Need to understand the initialization process
- Setting up the project structure correctly
- Understanding cookiecutter template usage

## Quick Start

The fastest way to start a new component:

```bash
cookiecutter gh:keboola/cookiecutter-python-component
```

Then clean up and configure:
1. Remove cookiecutter example files from `data/` directory
2. Create component-specific `data/config.json` with example parameters
3. Keep empty `data/` folder structure (not committed to git)

## Complete Initialization Guide

For detailed step-by-step instructions, see:
- [Initialization Guide](references/initialization.md) - Complete setup process

## What Happens During Initialization

The cookiecutter template creates:
- `src/` - Component Python code
- `component_config/` - Configuration schemas and descriptions
- `tests/` - Test structure
- `.github/workflows/` - CI/CD pipelines
- `Dockerfile` - Container definition
- `requirements.txt` - Python dependencies
- `data/` - Local testing directory (with examples to remove)

## After Initialization

Once initialized, you'll typically want to:
1. Implement component logic (use `@build-component` skill)
2. Design configuration schemas (use `@build-component-ui` skill)
3. Write tests (use `@test-component` skill)
4. Deploy to Developer Portal

## Key Resources

- **Cookiecutter Template**: https://github.com/keboola/cookiecutter-python-component
- **Component Tutorial**: https://developers.keboola.com/extend/component/tutorial/
- **Developer Docs**: https://developers.keboola.com/

## Next Steps

After getting started:
- For component development: Use `@build-component` skill
- For UI/schema work: Use `@build-component-ui` skill
- For testing: Use `@test-component` skill
- For debugging: Use `@debug-component` skill

Overview

This skill guides you through initializing and setting up a new Keboola Python component using the official cookiecutter template. It provides practical steps to create the project structure, clean sample files, and configure local testing data. Use it to get a working scaffold quickly and consistently for component development.

How this skill works

The skill walks you through running the cookiecutter generator and explains what files and folders the template creates (src, component_config, tests, CI workflows, Dockerfile, requirements, data). It describes the minimal cleanup and configuration tasks to make the scaffold ready for development and local testing. It also points to next steps for implementing logic, schemas, tests, and deployment.

When to use it

  • Starting a new Keboola Python component project from scratch
  • You need a standard, repeatable project scaffold and CI setup
  • Preparing a local testing data directory and initial config.json
  • Onboarding team members to component structure and conventions
  • Before implementing component logic, UI schema, or automated tests

Best practices

  • Run cookiecutter and immediately remove example files from the data/ directory
  • Create a component-specific data/config.json with example parameters for local testing
  • Keep an empty data/ folder structure in source control, but avoid committing example data
  • Define configuration schemas early in component_config/ to drive UI and validation
  • Add tests under tests/ and wire them into CI in .github/workflows/

Example use cases

  • Quickly scaffold a Keboola Python component to implement new integration logic
  • Set up a reproducible template for multiple team members to begin development
  • Prepare a component repo ready for schema-driven UI development and testing
  • Bootstrap a component when contributing an integration to Keboola Developer Portal
  • Create a local development environment with a sample config.json for manual runs

FAQ

What is the fastest way to create the scaffold?

Run cookiecutter gh:keboola/cookiecutter-python-component and follow prompts to generate the project.

What should I do with the data/ example files?

Remove the template example files, add a component-specific data/config.json for local testing, and keep an empty folder structure committed if needed.