Skip to content

DAGI Stack Open Core Model

Version: 0.2.0
License: MIT (core components)
Last Updated: 2024-11-15

🎯 Philosophy

DAGI Stack follows an Open Core model: - Core infrastructure is open-source (MIT License) - Advanced/proprietary features can remain private (optional) - Community-driven development with transparent roadmap

Goals: 1. Enable anyone to build AI routers and agent systems 2. Maintain flexibility for commercial/proprietary extensions 3. Foster ecosystem growth through shared infrastructure

✅ Open Source Components (MIT License)

Router Core

Why Open: Foundation for any routing system

  • routing_engine.py - Rule-based routing logic
  • config_loader.py - YAML configuration parser
  • router_app.py - FastAPI HTTP server
  • main_v2.py - Entry point and CLI

Use Cases: - Build custom AI routers - Extend routing rules - Integrate with any LLM/agent backend

Provider Interfaces

Why Open: Standard contracts for extensibility

  • providers/base_provider.py - Abstract provider interface
  • providers/registry.py - Provider discovery and registration
  • providers/llm_provider.py - LLM provider base class
  • providers/ollama_provider.py - Ollama integration
  • providers/openai_provider.py - OpenAI integration
  • providers/deepseek_provider.py - DeepSeek integration

Use Cases: - Add new LLM providers (Anthropic, Cohere, etc.) - Create custom agent providers - Integrate with proprietary backends

DevTools Backend

Why Open: Common development workflows

  • devtools-backend/main.py - FastAPI service
  • Endpoints: /fs/read, /fs/write, /ci/run-tests, /notebook/execute
  • File operations, test execution, notebook support

Use Cases: - Code review workflows - Automated testing - Workspace management

RBAC Service

Why Open: Foundational access control

  • microdao/rbac_api.py - Role resolution service
  • Role definitions (admin, member, contributor, guest)
  • Entitlement system

Use Cases: - Multi-tenant access control - DAO-based permissions - Custom role hierarchies

Bot Gateway

Why Open: Platform integrations

  • gateway-bot/main.py - Telegram/Discord webhooks
  • gateway-bot/http_api.py - HTTP endpoints
  • gateway-bot/router_client.py - Router client

Use Cases: - Add new platforms (Slack, WhatsApp) - Custom chat normalization - Webhook processing

Utilities

Why Open: Shared infrastructure

  • utils/logger.py - Structured JSON logging
  • utils/validation.py - Request validation
  • Request ID generation, error handling

Use Cases: - Consistent logging across services - Debugging and tracing - Production observability

Documentation

Why Open: Knowledge sharing

  • All .md files (README, guides, API docs)
  • Architecture diagrams
  • Deployment guides
  • Test scenarios

Use Cases: - Learn routing patterns - Deployment best practices - Community contributions

Test Suites

Why Open: Quality assurance

  • smoke.sh - Smoke test suite
  • test-devtools.sh - DevTools E2E tests
  • test-crewai.sh - CrewAI E2E tests
  • test-gateway.sh - Gateway E2E tests

Use Cases: - Validate custom deployments - Regression testing - CI/CD integration

⚠️ Proprietary/Private Components (Optional)

These can remain private for commercial or strategic reasons:

Custom CrewAI Workflows

Why Private: Domain-specific IP

  • orchestrator/crewai_backend.py - Workflow implementations
  • microDAO-specific workflows (onboarding, proposal review)
  • Agent configurations and prompts

Alternatives (Open): - Base CrewAI integration (open) - Workflow interface/API (open) - Example workflows (open)

Advanced RBAC Policies

Why Private: Competitive advantage

  • Custom DAO-specific rules
  • Complex entitlement logic
  • Integration with on-chain data

Alternatives (Open): - Base RBAC service (open) - Role resolution API (open) - Example policies (open)

LLM Fine-tuning Data

Why Private: Training data IP

  • Custom training datasets
  • Prompt engineering techniques
  • Model fine-tuning parameters

Alternatives (Open): - Provider interfaces (open) - Base model configurations (open)

Enterprise Features

Why Private: Revenue generation

  • SSO integration (SAML, OAuth)
  • Advanced audit logs
  • SLA guarantees
  • Premium support

Alternatives (Open): - Basic authentication (open) - Standard logging (open)

🔄 Contribution Model

Open Source Contributions

Welcome: - Bug fixes - Performance improvements - New provider implementations - Documentation updates - Test coverage - Example workflows

Process: 1. Fork repository 2. Create feature branch 3. Submit Pull Request 4. Code review by maintainers 5. Merge after approval

See: CONTRIBUTING.md

Commercial Extensions

Allowed: - Build proprietary services on top of DAGI Stack - Offer hosted versions (SaaS) - Create premium features - Provide consulting/support

Requirements: - Comply with MIT License terms - Attribute DAGI Stack in documentation - Consider contributing improvements back (optional)

📜 Licensing

MIT License Summary

Permissions: - ✅ Commercial use - ✅ Modification - ✅ Distribution - ✅ Private use

Conditions: - 📄 Include license and copyright notice

Limitations: - ⚠️ No liability - ⚠️ No warranty

Full License: LICENSE

🌐 Ecosystem Vision

Current State (v0.2.0)

  • Open-source core (Router, DevTools, RBAC, Gateway)
  • Example workflows and integrations
  • Production-ready deployment

Short-term (v0.3.0-v0.5.0)

  • Community provider implementations
  • Additional workflow examples
  • Integration guides (Dify, MCP)

Long-term (v1.0.0+)

  • Plugin marketplace
  • Hosted community instances
  • Certification program for providers
  • Enterprise support offerings

🤝 Partners & Integrations

Open Integrations

  • Ollama (local LLM)
  • OpenAI API
  • DeepSeek API
  • Telegram Bot API
  • Discord Webhooks

Planned Integrations

  • Dify (LLM backend)
  • MCP (Model Context Protocol)
  • Anthropic Claude
  • Hugging Face models
  • Web3 wallets (for DAO auth)

📊 Metrics & Transparency

Public Metrics (Planned)

  • GitHub stars/forks
  • Active contributors
  • Issue resolution time
  • Release cadence
  • Community size (Discord)

Development Transparency

  • Public roadmap (GitHub Projects)
  • Open issue tracker
  • Public discussions
  • Regular community calls (planned)

💬 Community

  • GitHub: https://github.com/daarion/dagi-stack
  • Discord: https://discord.gg/daarion
  • Discussions: https://github.com/daarion/dagi-stack/discussions
  • Email: dev@daarion.city

🎉 Why Open Core?

  1. Accelerate Innovation: Community contributions improve core faster
  2. Reduce Vendor Lock-in: Users can self-host, modify, extend
  3. Build Trust: Transparent codebase, security audits possible
  4. Ecosystem Growth: More providers = more value for everyone
  5. Sustainable Business: Commercial extensions fund ongoing development

DAGI Stack is infrastructure, not a product. By open-sourcing the core, we enable the entire DAARION ecosystem to build on a shared foundation while maintaining flexibility for specialized/commercial use cases.

Version: 0.2.0
License: MIT (core)
Last Updated: 2024-11-15