Introduction ​

KDeps is a YAML-based workflow framework for building AI agents on edge devices and API backends. It combines multi-source hardware I/O (audio, video, telephony), offline-capable LLMs, speech recognition, wake-phrase activation, and text-to-speech into portable, self-contained units that run anywhere — from Raspberry Pi to cloud servers.

Key Highlights ​

Multi-Source I/O for Edge Devices ​

KDeps accepts input from hardware devices and HTTP APIs — simultaneously. Configure audio, video, telephony, and API sources in one workflow.yaml:

settings:
  input:
    sources: [audio]          # audio | video | telephony | api
    audio:
      device: hw:0,0          # ALSA device (Linux), microphone name (macOS/Windows)
    activation:
      phrase: "hey kdeps"     # Wake phrase — workflow runs only when heard
      mode: offline
      offline:
        engine: faster-whisper
        model: small
    transcriber:
      mode: offline           # Fully local, no cloud required
      output: text
      offline:
        engine: faster-whisper
        model: small

Full Input Sources guide →

Offline-First AI Stack ​

Every AI component has an offline alternative — run completely air-gapped:

YAML-First Configuration ​

Build workflows using simple, self-contained YAML configuration blocks. No complex programming required - just define your resources and let KDeps handle the orchestration.

apiVersion: kdeps.io/v1
kind: Workflow
metadata:
  name: my-agent
  version: "1.0.0"
  targetActionId: responseResource
settings:
  apiServerMode: true
  apiServer:
    portNum: 16395
    routes:
      - path: /api/v1/chat
        methods: [POST]

Fast Local Development ​

Run workflows instantly on your local machine with sub-second startup time. Docker is optional and only needed for deployment.

# Run locally (instant startup)
kdeps run workflow.yaml

# Hot reload for development
kdeps run workflow.yaml --dev

Unified API ​

Access data from any source with just two functions: get() and set(). No more memorizing 15+ different function names.

# All of these work with get():
query: get('q')                    # Query parameter
auth: get('Authorization')         # Header
data: get('llmResource')           # Resource output
user: get('user_name', 'session')  # Session storage

Mustache Expressions ​

KDeps v2 supports both expr-lang and Mustache-style variable interpolation:

# expr-lang (functions and logic)
prompt: "{{ get('q') }}"
time:   "{{ info('current_time') }}"

# Mustache (simple variable access)
prompt: "{{q}}"
time:   "{{current_time}}"

# Mix in the same workflow
message: "Hello {{name}}, your score is {{ get('points') * 2 }}"

Use Mustache for simple variable access; use expr-lang for function calls, arithmetic, and conditionals. and are identical.

Learn more →

LLM Integration ​

Use Ollama for local model serving or any OpenAI-compatible API. Vision, tools, and streaming are supported.

Quick Start ​

# Install KDeps (Mac/Linux)
curl -LsSf https://raw.githubusercontent.com/kdeps/kdeps/main/install.sh | sh

# Or via Homebrew (Mac)
brew install kdeps/tap/kdeps

# Create a new agent interactively
kdeps new my-agent

Example: Simple Chatbot ​

workflow.yaml

apiVersion: kdeps.io/v1
kind: Workflow
metadata:
  name: chatbot
  version: "1.0.0"
  targetActionId: responseResource
settings:
  apiServerMode: true
  apiServer:
    portNum: 16395
    routes:
      - path: /api/v1/chat
        methods: [POST]
  agentSettings:
    models:
      - llama3.2:1b

resources/llm.yaml

apiVersion: kdeps.io/v1
kind: Resource
metadata:
  actionId: llmResource
  name: LLM Chat
run:
  chat:
    model: llama3.2:1b
    prompt: "{{ get('q') }}"
    jsonResponse: true
    jsonResponseKeys:
      - answer

resources/response.yaml

apiVersion: kdeps.io/v1
kind: Resource
metadata:
  actionId: responseResource
  requires:
    - llmResource
run:
  apiResponse:
    success: true
    response:
      data: get('llmResource')

Test it:

kdeps run workflow.yaml
curl -X POST http://localhost:16395/api/v1/chat -d '{"q": "What is AI?"}'

Documentation ​

Getting Started ​

• Installation
• Quickstart
• CLI Reference

Configuration ​

• Workflow
• Session & Storage
• CORS
• Advanced

Resources ​

• Overview
• LLM (Chat) · LLM Backends
• TTS · HTTP Client
• SQL · Python · Exec
• API Response

Concepts ​

• Input Sources · Unified API
• Expressions · Expression Functions Reference
• Request Object · Input Object
• Tools · Items Iteration
• Validation · Error Handling
• Inline Resources · Route Restrictions
• Management API

Deployment ​

• Docker · WebServer Mode

Tutorials ​

• Building a Chatbot · File Upload
• Multi-Database · Vision

Why KDeps v2? ​

Examples ​

Explore working examples:

Edge AI / Voice:

• Voice Assistant - Offline wake-phrase + LLM + TTS on edge hardware
• Vision Surveillance - Camera capture + vision LLM analysis

API Backends:

• Simple Chatbot - LLM chatbot
• ChatGPT Clone - Full chat UI
• File Upload - File processing
• HTTP Advanced - API integration
• SQL Advanced - Multi-database
• Batch Processing - Items iteration
• Tools - LLM function calling
• Vision - Image processing

Community ​

• GitHub: github.com/kdeps/kdeps
• Issues: Report bugs and request features
• Contributing: CONTRIBUTING.md
• Examples: Browse example workflows