cachibot 0.2.58

The Armored AI Agent. Cross-platform, secure, yours.

CachiBot

The Armored AI Agent

Visual. Transparent. Secure.

Website · Español · 中文版 · Português

A visual AI agent platform with full transparency. Named after the Venezuelan cachicamo (armadillo) — built to be armored, auditable, and yours to control.

Install · Features · Architecture · Security · Contributing · Discord

---

Why CachiBot?

Most AI platforms force you to choose: chatbot UIs with no automation, workflow builders with no conversational AI, or developer frameworks that take weeks to ship.

CachiBot gives you all three. Build specialized bots, deploy them to any messaging platform, run them in collaborative rooms, and automate workflows — all from a visual dashboard with full transparency into what your agents are doing.

Install

Linux / macOS

curl -fsSL cachibot.ai/install.sh | bash

Sets up Python, a virtual environment, and a systemd service — everything you need in one command.

Windows

irm cachibot.ai/install.ps1 | iex

pip

pip install cachibot

Then start the server:

cachibot server

Open http://localhost:6392 — the frontend is bundled and served automatically. No separate build step.

Configure your API keys

You can set API keys directly from the dashboard UI — no environment variables required. Just open the settings panel and add your keys there.

If you prefer environment variables, those work too:

export OPENAI_API_KEY="your-key"       # OpenAI / GPT-4
export ANTHROPIC_API_KEY="your-key"    # Claude
export MOONSHOT_API_KEY="your-key"     # Kimi
# or use Ollama locally (no key needed)

CLI Usage

cachibot server                    # Start the dashboard
cachibot "summarize this project"  # Run a single task
cachibot                           # Interactive mode
cachi server                       # Short alias

Features

Multi-Agent Platform

• Unlimited Specialized Bots — Create bots with custom system prompts, tool selections, and model routing
• Collaborative Rooms — Run 2-4 bots together in real-time to solve complex tasks
• Bot Marketplace — Pre-built templates for common use cases (code review, data analysis, writing, support)

Platform Integrations

Deploy bots to 7 messaging platforms with built-in adapters:

Telegram · Discord · Slack · Microsoft Teams · WhatsApp · Viber · LINE

Multimodal AI

• Voice Conversations — Talk to your bots with real-time speech-to-text and text-to-speech
• Image Generation — DALL-E, Google Imagen, Stability AI, Grok
• Audio Synthesis — OpenAI TTS, ElevenLabs
• 12+ LLM Providers — Claude, GPT-4, Kimi, Gemini, Ollama, Groq, and more

50+ Built-in Tools

Powered by Tukuy plugins:

• File operations, sandboxed Python execution, web search
• Knowledge base with vector search and document upload
• Task management, scheduling (cron, interval, event-triggered), background jobs
• Git operations, HTTP requests, SQL queries
• Reusable functions with step-level dependencies and retries

Security & Control

• Visual Approval Flows — Approve or reject risky operations before they execute
• Sandboxed Execution — Python runs in isolation with AST-based risk analysis
• Workspace Isolation — All file access scoped to the workspace
• Full Audit Trail — Every action logged and visible in the dashboard

What Can You Build?

• Customer Support Bot — Deploy to Telegram with a knowledge base of your docs, auto-answer FAQs
• Data Analysis Room — 3 bots (SQL specialist + Python analyst + report writer) collaborating on insights
• Voice Assistant — Talk to a bot with STT/TTS, manage tasks and reminders hands-free
• Content Pipeline — Research bot + writer bot + image generator producing blog posts end-to-end
• DevOps Agent — Monitor repos, run sandboxed scripts, send alerts to Slack on schedule

Architecture

graph TB
    subgraph Frontend["React Dashboard"]
        Bots[Bots & Rooms]
        Chats[Chats & Voice]
        Work[Jobs, Tasks & Schedules]
        KB[Knowledge Base]
        Market[Marketplace]
    end

    subgraph Backend["FastAPI Backend"]
        Agent["Prompture Agent"]
        Plugins["Tukuy Plugin System"]
        Sandbox["Python Sandbox"]
        Auth["Auth & RBAC"]
        Scheduler["Scheduler Service"]
    end

    subgraph Providers["AI Providers"]
        LLM["LLMs (Claude, GPT-4, Kimi, Ollama, Groq, ...)"]
        ImgGen["Image Gen (DALL-E, Imagen, Stability)"]
        Audio["Audio (Whisper, ElevenLabs)"]
    end

    subgraph Platforms["Platform Integrations"]
        TG[Telegram]
        DC[Discord]
        SL[Slack]
        TM[Teams]
        WA[WhatsApp]
        VB[Viber]
        LN[LINE]
    end

    Frontend -- "WebSocket / REST" --> Backend
    Backend --> Providers
    Backend --> Platforms

Supported Providers

CachiBot uses Prompture for model management with auto-discovery — set an API key and available models appear automatically.

Provider	Example Models	Environment Variable
OpenAI	GPT-4o, GPT-4, o1	OPENAI_API_KEY
Anthropic	Claude Sonnet, Opus, Haiku	ANTHROPIC_API_KEY
Moonshot	Kimi K2.5	MOONSHOT_API_KEY
Google	Gemini Pro, Flash	GOOGLE_API_KEY
Groq	Llama 3, Mixtral	GROQ_API_KEY
Grok/xAI	Grok-2	GROK_API_KEY
Ollama	Any local model	(no key needed)

All keys can also be configured from the dashboard UI without touching environment variables.

Security

CachiBot is built with security as a core principle. Visibility is security — the biggest risk with AI agents is not knowing what they're doing.

Sandboxed Execution

Python code runs in a restricted environment:

• Import Restrictions — Only safe modules allowed (json, math, datetime, etc.)
• Path Restrictions — File access limited to the workspace via SecurityContext
• Execution Timeout — Code killed after timeout (default: 30s)
• Risk Analysis — AST-based scoring (SAFE / MODERATE / DANGEROUS) before execution
• Approval Flow — Dangerous operations require explicit approval through the dashboard

Always Blocked

These are never allowed regardless of configuration: subprocess, os.system, ctypes, socket, ssl, importlib, eval, exec, pickle, marshal.

Roadmap

• Visual dashboard with real-time monitoring
• Multi-bot management with marketplace templates
• Sandboxed Python execution with AST risk analysis
• Multi-provider LLM support (12+ providers)
• Knowledge base with vector search and document upload
• 7 platform integrations (Telegram, Discord, Slack, Teams, WhatsApp, Viber, LINE)
• Plugin system with 50+ tools (via Tukuy)
• Multi-agent collaborative rooms
• Voice conversations (STT/TTS)
• Image and audio generation
• Background jobs with cron/interval/event scheduling
• Work management (tasks, todos, functions)
• Authentication and role-based access control
• Mobile companion app

Contributing

Contributions are welcome! See CONTRIBUTING.md for the full guide. Quick start:

git clone https://github.com/jhd3197/CachiBot.git
cd CachiBot

# Backend
python -m venv venv && source venv/bin/activate  # or .\venv\Scripts\activate on Windows
pip install -e ".[dev]"

# Frontend
cd frontend && npm install && cd ..

# Desktop (optional — only if working on the Electron shell)
cd desktop && npm install && cd ..

# Run everything
bash dev.sh              # or .\dev.ps1 on Windows
bash dev.sh desktop      # with Electron

See CONTRIBUTING.md for all dev script modes, project structure, testing, and code style guidelines.

Community

License

MIT License — see LICENSE for details.

Credits

• Built with Prompture for structured LLM interaction and multimodal drivers
• Plugin system powered by Tukuy
• Named after the Venezuelan cachicamo (armadillo)

---

Made with care by Juan Denis