Skip to content

renesul/Elyon

BranchesTags

Repository files navigation

███████╗██╗  ██╗   ██╗ ██████╗ ███╗   ██╗
██╔════╝██║  ╚██╗ ██╔╝██╔═══██╗████╗  ██║
█████╗  ██║   ╚████╔╝ ██║   ██║██╔██╗ ██║
██╔══╝  ██║    ╚██╔╝  ██║   ██║██║╚██╗██║
███████╗███████╗██║   ╚██████╔╝██║ ╚████║
╚══════╝╚══════╝╚═╝    ╚═════╝ ╚═╝  ╚═══╝

Personal AI

Multi-channel AI assistant — one binary, zero config files to edit, everything through the web UI.

Go 1.25+ Platform CGO License

📑 Table of Contents

✨ Features

🧠 LLM & Routing

  • 13+ LLM vendors — OpenAI, Anthropic, Google Gemini, DeepSeek, Groq, Ollama, OpenRouter, and more
  • Smart fallback — automatic load-balancing, cooldown, and failover across providers per model type
  • Intelligent routing — complexity-based message routing between primary and light models

💬 Channels & Media

  • 5 chat channels — Telegram, Discord, WhatsApp, Slack, built-in web chat
  • Vision / image analysis — dedicated image model routing on any channel that sends photos
  • Voice transcription — automatic audio-to-text via any OpenAI-compatible transcription provider

🤖 Agent System

  • Agent loop — ReAct planner + parallel tool execution + sub-agent spawning
  • Skills — extensible skill system with 9 built-in skills
  • MCP — Model Context Protocol support (stdio + HTTP/SSE)
  • Persona documents — customize identity, personality, and behavior via markdown (stored in DB)

🏗️ Infrastructure

  • Single binary — no CGO, no external dependencies
  • SQLite storage — sessions, memory, models, providers, documents, cron jobs — no config files
  • RAG — semantic long-term memory via vector embeddings (SQLite-backed)
  • Web UI — Nuxt 4/Vue 3 config editor with i18n (EN/PT-BR/ES), contextual help, real-time logs, test chat
  • Heartbeat & Cron — scheduled tasks and periodic agent check-ins
  • Integrations — Email (IMAP/SMTP), Google Calendar, Home Assistant

🚀 Quick Start

1. Build & install

make build && make install

2. Launch

elyon              # starts gateway + web UI
elyon -version     # show version info
elyon -debug       # verbose logging
Terminal output 
███████╗██╗  ██╗   ██╗ ██████╗ ███╗   ██╗
██╔════╝██║  ╚██╗ ██╔╝██╔═══██╗████╗  ██║
█████╗  ██║   ╚████╔╝ ██║   ██║██╔██╗ ██║
██╔══╝  ██║    ╚██╔╝  ██║   ██║██║╚██╗██║
███████╗███████╗██║   ╚██████╔╝██║ ╚████║
╚══════╝╚══════╝╚═╝    ╚═════╝ ╚═╝  ╚═══╝

✓ elyon v1.0.0 — http://localhost:18800

3. Configure

  1. Open http://localhost:18800
  2. Add your LLM API key in the Providers tab
  3. Enable a channel (Telegram, Discord, WhatsApp, Slack) or use the built-in web chat

4. Chat — done!

All logs go to ~/.elyon/logs/ and the Web UI log viewer. Use -debug for verbose terminal output. On first run, Elyon creates ~/.elyon/ with a SQLite database seeded with default providers, models, settings, and workspace documents.

🔧 Built-in Tools

Category Tool Description
Filesystem read_file Read files from workspace
write_file Write files to workspace
edit_file Edit file with search/replace
append_file Append content to file
list_dir List directory contents
send_file Send file to chat channel
Execution exec Run shell commands (sandboxed)
spawn Spawn sub-agent for parallel tasks
subagent Delegate to specialized sub-agents
Web web_search Search the web
web_fetch Fetch URL contents
Communication message Send message to a channel
speak Text-to-speech output
Memory & Profile save_feedback Store user feedback for learning
update_owner_profile Update owner profile information
Scheduling cron Manage scheduled jobs
manage_event_rules Create/edit event-driven rules
Integrations email Send/read email (IMAP/SMTP)
calendar Google Calendar operations
home_assistant Home Assistant control
imagine Image generation
Skills find_skills Search skill registry
install_skill Install skills from registry
Hardware i2c I2C bus communication
spi SPI bus communication

MCP tools are dynamically added from connected MCP servers, prefixed with the server name.

🧩 Skills

9 built-in skills, extensible via the skill registry:

Skill Description
browser Web browsing and page interaction
calendar Google Calendar management
email Email composition and management
github GitHub repository operations
homeassistant Smart home device control
skill-creator Create new custom skills
summarize Content summarization
tmux Terminal multiplexer control
weather Weather forecasts and conditions

Skills are loaded from three locations (priority order): workspace → global (~/.elyon/skills/) → built-in.

🌐 Supported Vendors (13+)

All vendors use the OpenAI-compatible HTTP protocol — just set the API key in the Providers tab:

Vendor Prefix Vendor Prefix
OpenAI openai/ NVIDIA nvidia/
Anthropic anthropic/ Cerebras cerebras/
Google Gemini google/ Together together/
DeepSeek deepseek/ Qwen qwen/
Groq groq/ Ollama ollama/
Mistral mistral/
xAI xai/
OpenRouter openrouter/

Any OpenAI-compatible provider works — add it in the Providers tab with a custom api_base. Multiple model entries with the same model_name are automatically load-balanced (round-robin).

⚙️ Configuration

All configuration is done through the Web UI at http://localhost:18800. Everything lives in SQLite — no config files.

ELYON_HOME=/srv/elyon elyon   # custom base directory (default: ~/.elyon)
Resource Table Managed via
Providers providers Web UI → Providers tab
Models models Web UI → Models tab
Documents documents Web UI → Documents tab
Sessions sessions + messages Automatic
Cron jobs cron_jobs Web UI → Cron tab
Settings settings Web UI — per-section API (/api/settings/{key})

Model Types

Type Purpose Example
default Primary chat model openai/gpt-4.1-mini
image Vision/image analysis google/gemini-2.5-flash
embedding RAG vector embeddings openai/text-embedding-3-small
transcription Audio-to-text groq/whisper-large-v3-turbo

Fallback Chain

Each model type supports fallback models. When the primary model fails (rate limit, timeout), the system automatically tries the next fallback. Configure fallbacks in the Agents tab under defaults.

Model Type Primary field Fallbacks field
Primary model_name model_fallbacks
Image image_model image_model_fallbacks
Light (routing) routing.light_model routing.light_model_fallbacks

📐 Architecture

Message Flow

Incoming Message (Telegram, Discord, WhatsApp, Slack, Web Chat)
    │
    ▼
 Channel Adapter (app/input/)
    │  ├─ audio → Voice Transcription (configurable provider)
    │  └─ image → Media Store (downloaded + base64)
    ▼
 Route Resolver (app/routing/)
    │
    ▼
 Agent Instance (app/orchestrator/)
    │
    ▼
 Context Assembly (persona documents + RAG)
    │
    ▼
 Model Router
    │  ├─ image detected → Image Model + fallbacks
    │  ├─ light message  → Light Model + fallbacks (optional)
    │  └─ default        → Primary Model + fallbacks
    ▼
 ReAct Loop (LLM → tool calls → observe → repeat)
    │
    ▼
 Response → Channel

Project Structure

main.go                  Entry point: flag parsing + gateway startup

app/                     Business logic
  orchestrator/          AgentLoop, AgentInstance, Registry
  planning/              ReAct loop: LLM → tool calls → observe → repeat
  execution/             Tool registry (~20 tools)
  memory/                SQLite sessions, RAG (vector embeddings)
  context/               System prompt assembly from persona documents + RAG
  routing/               Route resolver, model router (complexity-based)
  input/                 Channel adapters + message bus

providers/               LLM backends (Anthropic native + OpenAI-compatible)

internal/                Infrastructure
  startup/               Gateway lifecycle, onboarding, graceful shutdown
  config/                Config loader + hot-reload
  db/                    SQLite database, schema, seed data
  logger/                Structured logging
  auth/                  Authentication (token, OAuth)
  voice/                 Audio transcription (OpenAI-compatible endpoint)
  media/                 Media store with TTL cleanup
  heartbeat/             Periodic agent check-ins
  cron/                  Scheduled job execution (SQLite-backed)
  skills/                Skill system
  webui/                 Web UI APIs + embedded Nuxt SPA
  mcp/                   MCP client + server

webui/                   Nuxt/Vue frontend source
  app/components/        Vue components (orchestrator, models, auth, etc.)
  app/stores/            Pinia stores (config, models, auth, ui)
  app/schemas/           Zod validation schemas

Data Storage

~/.elyon/
├── logs/                Structured log files
└── workspace/
    ├── elyon.db         SQLite database (settings, models, providers, sessions, documents, cron, auth)
    ├── memory/          Long-term memory (RAG-indexed)
    └── skills/          Skill packages

🐳 Docker

docker build -t elyon .
docker run -d --name elyon -v ~/.elyon:/home/elyon/.elyon -p 18800:18800 elyon

🛠️ Development

make build          # Build binary (output: build/elyon)
make test           # Run all tests
make lint           # Run golangci-lint
make fmt            # Format code
make check          # deps + fmt + vet + test (full CI check)
make install        # Build and install to ~/.local/bin
make generate       # Run go generate (required before build/test)

Web UI Development

cd webui
npm install
npm run dev         # Nuxt dev server with proxy to localhost:18800

Requirements

Requirement Details
Go 1.25+
CGO Disabled (pure Go)
OS Linux amd64/arm64

🧱 Tech Stack

Component Technology
Language Go (pure, no CGO)
Database SQLite (embedded)
Embeddings Vector similarity (SQLite-backed)
LLM Clients Anthropic native + OpenAI-compatible
MCP stdio + HTTP/SSE transport
Web UI Nuxt 4 / Vue 3 + Tailwind CSS v4

📄 Credits & License

Fork of PicoClaw, based on OpenClaw.

Licensed under the MIT License.

Built with Go

About

Elyon — Personal AI

Resources

Readme

License

MIT license
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

 
 
 

Contributors

Languages