Metadata-Version: 2.4
Name: krakenwhip
Version: 0.1.0
Summary: Deploy AI stacks with one command — OpenClaw, Ollama, and Qdrant, fully containerized.  Default LLM: Anthropic (Claude) when ANTHROPIC_API_KEY is set; Ollama (Llama 3.2) as fallback. Set ANTHROPIC_API_KEY in your environment or in ~/.krakenwhip/deployments/openclaw/.env. KrakenWhip prompts for it during `krakenwhip deploy openclaw` if not set.
Project-URL: Homepage, https://github.com/NeuroGamingLab/krakenwhip
Project-URL: Documentation, https://github.com/NeuroGamingLab/krakenwhip#readme
Project-URL: Repository, https://github.com/NeuroGamingLab/krakenwhip
Project-URL: Issues, https://github.com/NeuroGamingLab/krakenwhip/issues
Author: NeuroGamingLab
License-Expression: MIT
License-File: LICENSE
Keywords: ai,deploy,docker,infrastructure,ollama,openclaw,qdrant
Classifier: Development Status :: 3 - Alpha
Classifier: Environment :: Console
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Topic :: Software Development :: Build Tools
Classifier: Topic :: System :: Systems Administration
Requires-Python: >=3.9
Requires-Dist: httpx>=0.24.0
Requires-Dist: jinja2>=3.1.0
Requires-Dist: python-dotenv>=1.0.0
Requires-Dist: pyyaml>=6.0
Requires-Dist: rich>=13.0.0
Requires-Dist: typer>=0.9.0
Provides-Extra: cloud
Requires-Dist: python-hcl2>=4.0.0; extra == 'cloud'
Provides-Extra: dev
Requires-Dist: mypy; extra == 'dev'
Requires-Dist: pytest-cov; extra == 'dev'
Requires-Dist: pytest>=7.0; extra == 'dev'
Requires-Dist: ruff; extra == 'dev'
Description-Content-Type: text/markdown

# 🐙 KrakenWhip

**Deploy AI stacks with one command — OpenClaw and more, containerized by KrakenWhip.**

KrakenWhip takes the pain out of AI infrastructure: **one command** spins up OpenClaw (and Ollama, Qdrant) **fully containerized**—no host installs, no config archaeology. Run it locally with Docker Compose or ship it to the cloud with Terraform. Same stack, same containers, anywhere.

## Overview

KrakenWhip is a Python CLI that deploys pre-built **AI stacks** so you can run OpenClaw, Ollama, Qdrant, and similar tools without wiring Docker and config by hand.

- **Local:** Docker Compose stacks under `~/.krakenwhip/deployments/<stack>/` — all services run in containers and are exposed on localhost (no host installs).
- **Cloud (Pro):** Terraform-based deploys (Azure supported; AWS, GCP, DigitalOcean planned)

**Tech stack:** Typer + Rich for the CLI, Jinja2 for templates, `docker compose` (with fallback to standalone `docker-compose`). Cloud: Terraform with Azure provider. Python 3.9+.

**How it works:** Templates live in `krakenwhip/templates/` (e.g. `openclaw`, `ollama`, `rag`). Each has a `docker-compose.yml.j2`, optional `config/` and `env.example`. The deploy flow creates the deployment dir, renders templates, runs `docker compose pull` and `up`, and can pre-pull Ollama models. Use `krakenwhip doctor` to check Docker, disk, and ports.

**Highlights:** Clear separation (CLI, deploy engine, templates, doctor), good UX (progress, dry-run, panels), CI on Python 3.10–3.12 with ruff and pytest. OpenClaw stack is the primary, fully supported path.

**Current limitations:** Pro/cloud path requires a license key (check not yet implemented). Cloud deploy exits after the license prompt — Terraform is not invoked from the CLI yet. The `ollama` and `rag` templates are in the registry but may be incomplete.

## Quick Start

```bash
pip install krakenwhip

# Deploy OpenClaw stack locally (free)
krakenwhip deploy openclaw
# Gateway: http://localhost:18789   Qdrant: http://localhost:6333

# Deploy to Azure (pro)
krakenwhip deploy openclaw --cloud azure
```

The OpenClaw stack uses **Anthropic (Claude)** as the default model when `ANTHROPIC_API_KEY` is set (prompted during setup or in `~/.krakenwhip/deployments/openclaw/.env`). **Ollama (Llama 3.2)** is configured as fallback when the key is missing or for local-only use.

## What You Get

### `krakenwhip deploy openclaw`

A complete AI assistant stack:
- **OpenClaw** — personal AI agent framework (gateway on port **18789** by default)
- **Ollama** — local LLM inference (Llama, Mistral, Qwen, etc.); **default** is Anthropic (Claude) when `ANTHROPIC_API_KEY` is set, with Ollama as fallback
- **Qdrant** — vector database for memory (API and dashboard on port **6333**)

**Important:** OpenClaw, Ollama, and Qdrant all **run inside Docker containers**. Nothing is installed directly on your host. Container ports are mapped to **localhost**, so you use the stack at `http://localhost:18789` (gateway) and `http://localhost:6333` (Qdrant)—containers on the inside, localhost on the outside.

All pre-configured, networked, and ready to go. Deployment files and secrets live in `~/.krakenwhip/deployments/openclaw/` (including `.env` and `config/`). To change ports or re-run compose, use the same directory:

```bash
cd ~/.krakenwhip/deployments/openclaw
# Optional: edit docker-compose.yml or .env, then:
docker compose up -d
```

## ASCII Architecture Diagram

OpenClaw stack deployed by KrakenWhip — all services run in containers; you access them via localhost.

```
                    ┌─────────────────────────────────────────────────────────┐
                    │  Host (localhost)                                        │
                    │                                                          │
  krakenwhip        │   :18789 (gateway)        :6333 (Qdrant API/dashboard)   │
  deploy openclaw   │         │                          │                     │
        │           │         ▼                          ▼                     │
        ▼           │  ┌──────────────┐            ┌──────────────┐          │
  ┌─────────────┐   │  │   Browser    │            │   Browser     │          │
  │ KrakenWhip  │   │  │   / Client  │            │   / Client   │          │
  │    CLI      │   │  └──────┬───────┘            └──────┬───────┘          │
  └──────┬──────┘   │         │                          │                     │
         │          │         │                          │                     │
         │          │  ┌──────┴──────────────────────────┴──────┐             │
         │          │  │  Docker bridge network (krakenwhip)     │             │
         │          │  │                                         │             │
         └──────────┼──┼──► ┌─────────────────┐                  │             │
                    │  │    │ krakenwhip-     │                  │             │
                    │  │    │ openclaw        │◄─── :18789       │             │
                    │  │    │ (gateway + UI)  │                  │             │
                    │  │    └────────┬────────┘                  │             │
                    │  │             │                           │             │
                    │  │      ┌──────┴──────┐                    │             │
                    │  │      ▼             ▼                    │             │
                    │  │  ┌─────────────────┐  ┌─────────────────┐            │
                    │  │  │ krakenwhip-     │  │ krakenwhip-      │◄──── :6333 │
                    │  │  │ ollama (LLM)    │  │ qdrant (vectors) │            │
                    │  │  └─────────────────┘  └─────────────────┘            │
                    │  └─────────────────────────────────────────┘             │
                    └─────────────────────────────────────────────────────────┘
```

- **KrakenWhip CLI** renders config and runs `docker compose up`; all services run **inside containers**.
- **OpenClaw** talks to Ollama and Qdrant over the internal network; only the gateway (18789) and Qdrant (6333) are exposed on localhost.

## Pricing

| Tier | What | Price |
|------|------|-------|
| **Free** | Local Docker Compose stacks | $0 |
| **Pro** | Cloud templates (Terraform), priority support | $15/mo or $29 one-time |

## Stack Templates

### Available Now
- `openclaw` — Full OpenClaw + Ollama + Qdrant
- `ollama` — LocalHost Ollama with model management
- `rag` — RAG pipeline (Qdrant + embeddings API)

### Coming Soon
- `langchain` — LangChain + vector store + API
- `comfyui` — ComfyUI + model cache

## Commands

```bash
krakenwhip deploy <stack>          # Deploy a stack locally
krakenwhip deploy <stack> --cloud <provider>  # Deploy to cloud (pro)
krakenwhip list                    # List available stacks
krakenwhip status [<stack>]         # Check running stacks
krakenwhip stop <stack>            # Stop a stack (preserves data)
krakenwhip destroy <stack>         # Remove a stack (use --volumes to remove data)
krakenwhip logs <stack>            # View stack logs
krakenwhip doctor                  # Diagnose common issues
```

**Deploy options** (e.g. for `openclaw`): `--port` / `-p` (gateway port), `--ollama-port` (expose Ollama on host), `--dry-run` (render config only), `--gpu`, `--models llama3.1,mistral`, `--api-key` / `-k` (Anthropic), `--skip-setup` (skip interactive prompts).

### Check Ollama and Qdrant

Use the **stack name you deployed** (e.g. `openclaw` if you ran `krakenwhip deploy openclaw`). Status and logs only work for stacks that are already deployed.

```bash
# If you deployed OpenClaw (includes Ollama + Qdrant)
krakenwhip status openclaw
krakenwhip logs openclaw --service ollama
krakenwhip logs openclaw --service qdrant

```

## Cloud Providers (Pro)

| Provider | Status |
|----------|--------|
| Azure | ✅ Available |
| AWS | 🔜 Coming Soon |
| GCP | 🔜 Coming Soon |
| DigitalOcean | 🔜 Coming Soon |

## Requirements

- Python 3.9+
- Docker & Docker Compose (for local deploys)
- Terraform (for cloud deploys, auto-installed if missing)

## License

MIT — Free and open source.

Cloud templates require a Pro license key.

---

Built by [NeuroGamingLab](https://github.com/NeuroGamingLab) · *Dare to Dream, Inspire Leadership, and Spark Innovation Through Diverse Ideas.*
