ABSORB

                                   ███
             █████              ████████
            ███████            ██████████
            ███████           ████████████
              ████             ██████████
              █████             ████████
             ███████████         ██████
            █████████████     ███████████        ███
           ██████████████   ███████████████    ████████
           ███████████████████████    ██████████████████
    █████████████████████████████     ██████████████████
   █████████████████████████████   █   █████████████████
    ███████  █████████   ███████  ███   ████   ███████
     ████        ██      ██████   ███     █
                         █████
                          ████
                           ██      ███
                                 ███████
                                █████████
                                █████████
                                 ███████
                                █████████
                              █████████████
                             ███████████████
                             ███████████████
                              █████████████
                                █████████

Multi-Model AI Orchestrator for Massive Plans, Specifications and Documentation

Absorb is a terminal-first AI orchestrator that combines up to three Large Language Models into a single planning engine capable of generating massive technical specifications, schedules, architectures, roadmaps and long-form project documentation.

---

✨ Features

• 🧠 Single Model Generation
• 🎼 Multi-Model Orchestra Mode
• 📋 Technical Specifications (TZ)
• 🗂️ Task Breakdown
• 📅 Development Schedules
• 📚 Comprehensive Project Plans
• 📄 Export to TXT, DOCX and PDF
• 🔌 OpenAI, Anthropic and OpenAI-Compatible APIs
• ⚡ Rich Terminal Interface
• 🧩 Provider Agnostic Architecture
• 💾 Local File Generation

---

⚡ Installation

git clone https://github.com/shell-windon/absorb
cd absorb
pip install -r requirements.txt

---

🚀 Quick Start

Generate a document:

python main.py generate -t "Website for online courses"

Generate a PDF:

python main.py generate -t "Website for online courses" -f pdf

Generate with Orchestra Mode:

python main.py generate -t "Website for online courses" -p comprehensive -f pdf -o

---

🧠 Command Syntax

python main.py generate \
    -t "<project description>" \
    -p <plan type> \
    -f <format> \
    [-o]

Argument	Description
-t	Project description or prompt
-p	Plan type
-f	Output format
-o	Enable Orchestra Mode

---

📋 Plan Types

tz             Technical Specification
tasks          Task Breakdown
schedule       Development Schedule
comprehensive  Full Project Documentation

Examples:

python main.py generate -t "FPS Game" -p tz -f pdf
python main.py generate -t "AI Startup" -p schedule -f docx
python main.py generate -t "Trading Platform" -p comprehensive -f pdf -o

---

🏛️ Architecture Overview

┌──────────────────────────────────────────────────────────────┐
│                        main.py                               │
│      CLI (click) + Interactive Mode (questionary)            │
└──────────┬──────────────────────────────────┬────────────────┘
           │                                  │
     ┌─────▼──────┐                   ┌──────▼─────────┐
     │ interactive│                   │ generate ...   │
     └─────┬──────┘                   └──────┬─────────┘
           │                                  │
           └──────────┬───────────────────────┘
                      │
         ┌────────────▼────────────┐
         │      Orchestrator       │
         │ generate_single()       │
         │ generate_orchestrated() │
         └────┬───────────┬────────┘
              │           │
      ┌───────▼───┐   ┌───▼────────────┐
      │ LLMClient │   │ LLMClient x N  │
      │ (1 model) │   │ ThreadPool     │
      └───────────┘   └──────┬─────────┘
                             ▼
                     Conductor / Synthesizer
                             ▼
                    TXT / DOCX / PDF Generator
                             ▼
                      User Output File

---

⚙️ Configuration Layer

Configuration is stored inside:

~/.absorb/config.json

Example:

{
  "models": [
    {
      "name": "GPT-4o-mini",
      "provider": "openai-compatible",
      "api_key": "sk-...",
      "model": "openai/gpt-4o-mini",
      "base_url": "https://openrouter.ai/api/v1"
    }
  ],
  "default_output_format": "txt",
  "smartest_model_index": 0
}

ModelConfig

Represents a single model:

• name
• provider
• api_key
• model
• base_url

AppConfig

• loads configuration
• saves configuration
• manages models
• limits orchestra to three models

---

🔌 Supported Providers

Provider	Supported
OpenAI	✅
Anthropic	✅
OpenAI-Co.	✅
DeepSeek	✅
Groq	✅
OpenRouter	✅
LM Studio	✅
Ollama	✅

---

🧠 LLM Layer

src/llm.py

Unified interface:

OpenAI / Compatible

client.chat.completions.create(...)

Anthropic

client.messages.create(...)

Universal API:

generate(system_prompt, user_prompt, max_tokens=16000)

---

📝 Prompt Templates

src/templates.py

System prompts:

• SYSTEM_EXPERT
• SYSTEM_SYNTHESIZER

Plan templates:

• comprehensive
• tz
• tasks
• schedule

---

🎼 Orchestra Mode

The core feature of Absorb.

Single Mode

User
 ↓
Template
 ↓
Model
 ↓
Final Plan

Orchestra Mode

User
 ↓
Template
 ↓
GPT
Claude
DeepSeek
 ↓
Conductor
 ↓
Super Plan

Workflow:

1. Run up to three models in parallel.
2. Collect all generated plans.
3. Send plans to the smartest model.
4. Synthesize a final document.

Example:

GPT writes Plan A.
DeepSeek writes Plan B.
GPT analyzes A+B and produces a superior plan.

---

📁 Project Structure

absorb/
│
├── main.py
├── src/
│   ├── config.py
│   ├── llm.py
│   ├── templates.py
│   ├── orchestrator.py
│   ├── ui.py
│   └── generators/
│       ├── txt.py
│       ├── docx.py
│       └── pdf.py

---

🖥️ Interactive Mode

1. Generate Plan (Single Model)
2. Generate Plan (Orchestrator)
3. Manage Models
4. Settings
5. About
0. Exit

Features:

• ASCII logo
• Rich tables
• Model manager
• Loading spinner
• Markdown preview
• About page

---

📦 Output

output/
├── project.txt
├── project.docx
└── project.pdf

Files are automatically saved to the user's directory.

Example:

Website_Online_Courses.pdf
Telegram_Bot_Finances.docx

---

🔥 Example Workflow

python main.py

1. Add Model.
2. Configure API.
3. Generate Plan.
4. Export.

Or:

python main.py generate \
-t "Telegram finance bot" \
-p comprehensive \
-f pdf \
-o

---

🚀 Roadmap

• Single Model Generation
• Orchestra Mode
• TXT Export
• DOCX Export Improvements
• PDF Templates
• Mermaid Diagrams
• UML Generation
• RAG Support
• Local Models
• GitHub Integration
• Jira Export
• Trello Export
• AI Memory

---

📜 License

MIT License

---

👨‍💻 Author

Created by Shell Windon

One model gives an answer. Several models give perspective. Absorb turns perspectives into a plan.