abstractframework 0.1.1

Unified installer and documentation hub for the AbstractFramework ecosystem

AbstractFramework

Build durable, observable AI systems — fully open source, works offline.

AbstractFramework is a modular ecosystem for building AI agents and workflows that survive restarts, scale to production, and give you full visibility into what's happening. Every component is open source, works with local models, and designed to be composed however you need.

This repository is the single access point to the ecosystem:

• install the full framework with one pip command
• understand how all packages fit together
• create and deploy new specialized solutions (flows/agents) across clients

┌──────────────────────────────────────────┬──────────────────────────────────┐
│   GATEWAY PATH (Recommended)             │   LOCAL PATH (Alternative)       │
├──────────────────────────────────────────┼──────────────────────────────────┤
│                                          │                                  │
│  Browser UIs (Observer, Flow Editor,     │  AbstractCode (terminal)         │
│  Code Web, Your App)                     │  AbstractAssistant (macOS tray)  │
│              │                           │             │                    │
│              ▼                           │             │                    │
│  ┌────────────────────────────────────┐  │             │                    │
│  │        AbstractGateway             │  │             │                    │
│  │  ────────────────────────────────  │  │             │                    │
│  │  Bundle discovery (specialized     │  │             │                    │
│  │  agents across all clients)        │  │             │                    │
│  │  Run control (start/pause/resume)  │  │             │                    │
│  │  Ledger streaming (real-time SSE)  │  │             │                    │
│  └──────────────────┬─────────────────┘  │             │                    │
│                     │                    │             │                    │
└─────────────────────┼────────────────────┴─────────────┼────────────────────┘
                      └──────────────────┬───────────────┘
                                         ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│  Composition: AbstractAgent (ReAct/CodeAct/MemAct) + AbstractFlow (.flow)   │
└─────────────────────────────────────────────────────────────────────────────┘
                                         │
                                         ▼
┌──────────────────────────────────────────────────────────────────────----───────┐
│  Foundation: AbstractRuntime + AbstractCore (+ Voice/Vision capability plugins) │
└──────────────────────────────────────────────────────────────────────────----───┘
                                         │
                                         ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│  Memory & Knowledge: AbstractMemory · AbstractSemantics                     │
└─────────────────────────────────────────────────────────────────────────────┘

Why AbstractFramework?

• 100% Open Source — MIT licensed, no black boxes, you own everything
• Local First — Run entirely offline with Ollama, LM Studio, or any local model
• Durable — Workflows survive crashes; resume exactly where you left off
• Observable — Every operation is logged; replay any run from history
• Modular — Use one package or the full stack; compose what you need

Quick Start

Option 1: Install the Full Framework (Recommended)

pip install "abstractframework==0.1.1"

abstractframework==0.1.1 installs the pinned global release:

Package	Version
abstractcore	2.11.8
abstractruntime	0.4.2
abstractagent	0.3.1
abstractflow	0.3.7
abstractcode	0.3.6
abstractgateway	0.2.1
abstractmemory	0.0.2
abstractsemantics	0.0.2
abstractvoice	0.6.3
abstractvision	0.2.1
abstractassistant	0.4.2

Default behavior in this release:

• abstractcore is installed with openai,anthropic,huggingface,embeddings,tokens,tools,media,compression,server
• abstractflow is installed with editor

Option 2: Select a Provider / Model

# Local (recommended)
ollama serve && ollama pull qwen3:4b

# Or use LM Studio
# Or cloud providers via env vars:
export OPENAI_API_KEY="..."
export ANTHROPIC_API_KEY="..."
export OPENROUTER_API_KEY="..."

Option 3: Terminal Agent (5 minutes)

abstractcode --provider ollama --model qwen3:4b

You now have a durable coding assistant in your terminal. Type /help to explore.

Durability: Your session persists across restarts — close and reopen, your full context is preserved. Start fresh with /clear.

Option 4: Tray Assistant (macOS)

assistant tray

The assistant appears in your menu bar. Click to interact, or use keyboard shortcuts.

Durability: Sessions persist — your conversation history is preserved across app restarts.

Option 5: Just the LLM API

Use AbstractCore as a drop-in unified LLM client that works with any provider and model:

from abstractcore import create_llm

llm = create_llm("ollama", model="qwen3:4b-instruct")
# llm = create_llm("openai", model="gpt-4o")
# llm = create_llm("anthropic", model="claude-3-5-sonnet-latest")

response = llm.generate("Explain durable execution in 3 bullets.")
print(response.content)

Option 6: Gateway + Browser UI

Deploy a run gateway and observe workflows in your browser:

export ABSTRACTGATEWAY_AUTH_TOKEN="for-my-security-my-token-must-be-at-least-15-chars"
export ABSTRACTGATEWAY_DATA_DIR="my-folder/runtime/gateway"

abstractgateway serve --port 8080
npx @abstractframework/observer        # Gateway observability dashboard
npx @abstractframework/flow            # Visual workflow editor
npx @abstractframework/code            # Browser coding assistant

Open http://localhost:3001, connect to the gateway, and start observing.

---

Install

Python (single command)

pip install "abstractframework==0.1.1"

Python (install specific components only)

pip install abstractcore==2.11.8
pip install "abstractflow[editor]==0.3.7"
pip install abstractgateway==0.2.1

JavaScript/Node (browser UIs)

# Web UIs (run directly)
npx @abstractframework/observer        # Gateway observability dashboard
npx @abstractframework/flow            # Visual workflow editor
npx @abstractframework/code            # Browser coding assistant

# UI component libraries (for building your own apps)
npm install @abstractframework/ui-kit
npm install @abstractframework/panel-chat
npm install @abstractframework/monitor-flow
npm install @abstractframework/monitor-active-memory
npm install @abstractframework/monitor-gpu

---

The Ecosystem

The tables below describe the ecosystem components. The abstractframework==0.1.1 install profile pins all Python packages to the versions listed in Quick Start.

Foundation

Package	What It Does	Install
AbstractCore	Unified LLM API — providers, tools, structured output, media	pip install abstractcore
AbstractRuntime	Durable execution — ledger, effects, pause/resume, replay	pip install abstractruntime

Composition

Package	What It Does	Install
AbstractAgent	Agent patterns — ReAct, CodeAct, MemAct loops	pip install abstractagent
AbstractFlow	Visual workflows — portable .flow bundles + editor	pip install abstractflow

Memory & Semantics

Package	What It Does	Install
AbstractMemory	Temporal triple store — provenance-aware, vector search	pip install abstractmemory
AbstractSemantics	Schema registry — predicates, entity types for KG	pip install abstractsemantics

Applications

Package	What It Does	Install
AbstractCode	Terminal TUI — durable coding assistant	pip install abstractcode
AbstractAssistant	macOS tray app — local agent with optional voice	pip install abstractassistant
AbstractGateway	HTTP server — remote runs, durable commands, SSE	pip install abstractgateway
AbstractObserver	Browser UI — observe, launch, and control runs	npx @abstractframework/observer

Modalities (AbstractCore Capability Plugins)

These are optional capability plugins for AbstractCore. Once installed, they expose additional capabilities on llm instances (e.g., llm.voice.tts(), llm.vision.t2i()), keeping AbstractCore lightweight by default.

Package	What It Does	Install
AbstractVoice	Voice I/O — adds llm.voice (TTS) and llm.audio (STT)	pip install abstractcore abstractvoice
AbstractVision	Image generation — adds llm.vision (text-to-image, image-to-image)	pip install abstractcore abstractvision

Web UIs (npm)

Package	What It Does	Install
@abstractframework/flow	Visual workflow editor (drag-and-drop)	npx @abstractframework/flow
@abstractframework/code	Browser-based coding assistant	npx @abstractframework/code

UI Components (npm)

Package	What It Does
@abstractframework/ui-kit	Theme tokens + UI primitives
@abstractframework/panel-chat	Chat thread + message cards + composer
@abstractframework/monitor-flow	Agent-cycle trace viewer
@abstractframework/monitor-active-memory	Knowledge graph explorer (ReactFlow)
@abstractframework/monitor-gpu	GPU utilization widget

---

Documentation

Guide	Description
Docs Index	Entrypoint docs for the ecosystem
Getting Started	Pick a path and run something
Architecture	How the pieces fit together
API	Meta-package API (create_llm, install profile helpers)
Configuration	Environment variables & providers
FAQ	Common questions
Scenarios	End-to-end paths by use case
Guides	Focused "how it works" notes
Glossary	Shared terminology

---

Create More Solutions

AbstractFramework is designed so you can author one specialized workflow and deploy it across clients.

1. Build your specialized logic in the Flow editor (npx @abstractframework/flow).
2. Export it as a .flow bundle with an interface contract (abstractcode.agent.v1).
3. Run it in terminal (abstractcode --workflow ...), browser UIs, or through abstractgateway.

See docs/getting-started.md Path 12 for a complete end-to-end example.

---

Philosophy

We built AbstractFramework because we wanted:

1. Full control — No vendor lock-in, no proprietary dependencies
2. Local by default — Privacy and cost control with open-source models
3. Durability — AI systems that don't lose work when things crash
4. Observability — Complete visibility, not a black box
5. Composability — Use what you need, replace what you don't

Cloud APIs are supported when you need them (complex reasoning tasks), but the framework is designed to run entirely on your hardware.

---

Contributing

Every package is its own repo. Find what interests you:

Foundation: AbstractCore · AbstractRuntime

Composition: AbstractAgent · AbstractFlow

Memory: AbstractMemory · AbstractSemantics

Apps: AbstractCode · AbstractAssistant · AbstractGateway · AbstractObserver

Modalities: AbstractVoice · AbstractVision

UI Components: AbstractUIC

---

License

MIT — see LICENSE.