# EDDI — Enterprise AI Orchestrator

> EDDI is a configuration-driven AI orchestration middleware built natively on the JVM (Java 25). Currently in v6.0.0-RC1 Preview. Apache 2.0 licensed. Website: https://eddi.labs.ai | GitHub: https://github.com/labsai/EDDI

## What is EDDI?

EDDI (Enhanced Dialog Driven Intelligence) is the only AI middleware that combines all three properties:

1. **JVM-native runtime** — Built on Java 25 with virtual threads for enterprise-grade concurrency
2. **Configuration-as-Code** — Agent logic defined as JSON configurations, not compiled code
3. **Visual Management UI** — A production-grade React management dashboard (EDDI Manager)

No other product in the market combines these three. Code libraries (Spring AI, LangChain4j) require recompilation. Visual builders (Flowise, n8n, Dify) run on Node.js/Python. Workflow engines (Camunda) weren't designed for AI.

## Key Capabilities

### Configuration-as-Code
- Agent behavior, pipelines, LLM settings, rules, and tools are all JSON configurations
- No Java code needed to create or modify agents
- Prompt engineers can iterate without developer involvement
- Import/export agents as JSON packages for CI/CD pipelines

### EDDI Manager (Visual UI)
- Full agent lifecycle: create → configure → deploy → test → monitor
- 8 dedicated resource editors: Rules, LLM Config, Output Sets, HTTP Calls, Workflows, Prompt Templates, Properties, Bot Configuration
- Side-panel live chat with integrated DebugDrawer (real-time tool calls, token usage, pipeline timing)
- Audit & Logs dashboards for per-task LLM details, cost tracking, and error analysis
- Coordinator events dashboard for multi-agent orchestration tracking
- 11-locale i18n: English, German, French, Spanish, Portuguese, Arabic (RTL), Chinese, Japanese, Korean, Hindi, Thai
- Dark/light theme, interactive onboarding tours

### MCP (Model Context Protocol) Server
- 48 MCP tools exposing all EDDI capabilities to external AI agents
- Claude Desktop, Cursor, and other MCP clients can manage EDDI agents programmatically
- EDDI agents can also consume external MCP tools as part of their pipelines

### Multi-Agent Orchestration
- Coordinator pattern for routing conversations to specialist agents
- Agents can delegate to other agents within the same EDDI instance
- Shared context and memory across coordinated conversations

### Stateful Agentic Memory
- Unified `IUserMemoryStore` handling isolated persistence paradigms
- 2D Property Scopes (Conversation vs User bounds) mapped against Visibility logic
- Native long-term memory retrieval without abstract vector orchestration

### Performance
- Java 25 virtual threads (Project Loom) — millions of concurrent conversations
- Sub-millisecond internal pipeline overhead
- JVM-native performance: no GIL, no event loop limitations
- Quarkus framework for fast startup and low memory footprint

### Security
- Zero user code execution — no eval(), no sandbox escapes, no template injection
- Cryptographic audit trails with HMAC-SHA256 integrity verification
- OIDC/Keycloak authentication with RBAC (eddi-admin, eddi-editor, eddi-viewer)
- Secrets Vault with AES-256-GCM envelope encryption
- Path traversal protection, URL validation, SSRF prevention
- PII-safe logging with SHA-256 pseudonymization

### Global Privacy & Regulatory Compliance
- **AI Governance**: EU AI Act (Art. 9-17), NIST AI RMF, ISO/IEC 42001
- **Data Privacy**: GDPR, CCPA/CPRA, PIPEDA, LGPD, APPI, POPIA, PDPA (Singapore & Thailand), UK GDPR, PIPA (South Korea), DPDPA (India), Australian Privacy Act
- **Industry**: HIPAA (US Healthcare), SOC 2 readiness
- **Unified API**: `DELETE /admin/gdpr/{userId}` (cascade erasure across 5 data stores), `GET /admin/gdpr/{userId}/export` (full data export), `POST /admin/gdpr/{userId}/restrict` (processing freeze)
- **MCP Tools**: `delete_user_data` and `export_user_data` for AI-orchestrated compliance workflows
- 15+ regulatory frameworks supported through one API

### Observability
- Native Prometheus metrics endpoint
- 45-panel Grafana "Operations Command Center" dashboard (auto-provisioned)
- Conversation lifecycle, tool execution, LLM latency, token usage, and error rate monitoring
- Integrated audit trail in the Manager UI

### Deployment
- Docker Compose (with Install Wizard for interactive setup)
- Kubernetes via Helm charts and Kustomize manifests
- Supports MongoDB OR PostgreSQL as backend database
- Optional NATS messaging for event-driven architectures
- Red Hat container certified

## Architecture

EDDI uses a pipeline-based architecture:

1. **Input Processing** — Normalize and validate incoming messages
2. **Pipeline Execution** — Sequential processing through configured task steps
3. **Task Types** — Rules evaluation, LLM calls, HTTP calls, property management
4. **Output Generation** — Template-based response rendering
5. **Audit & Logging** — Cryptographic audit trail for every interaction

### Resource Model
- **Bot** — Top-level container linking all resources
- **Packages** — Versioned bundles of resources (rules, LLM configs, etc.)
- **Conversations** — Stateful interaction sessions with memory

### LLM Integration
Supports multiple providers simultaneously:
- OpenAI (GPT-4o, o1, etc.)
- Anthropic (Claude 3.5, Claude 4)
- Google (Gemini 2.x)
- Ollama (local models)
- Azure OpenAI
- Any OpenAI-compatible endpoint

## API

### REST API
Full CRUD operations for all resources:
- `/botstore` — Bot management with deploy/undeploy
- `/packagestore` — Package configuration
- `/regulardictionarystore` — Rules and dictionaries
- `/outputstore` — Output templates
- `/httpcallsstore` — HTTP integration configurations
- `/conversationstore` — Conversation management
- `/propertiesstore` — Key-value property storage

### MCP Tools (48 total)
Organized by domain:
- Bot management (create, read, update, deploy, undeploy)
- Package management (create, read, update, add/remove resources)
- Conversation management (create, read, send messages, get logs)
- Resource CRUD (rules, LLM configs, output sets, HTTP calls, properties)
- System operations (health check, metrics)

## Comparison Matrix

| Factor | EDDI | Flowise/n8n/Dify | Spring AI/LC4j | Camunda |
|--------|------|-------------------|----------------|---------|
| Runtime | JVM (Java 25) | Node.js / Python | JVM | JVM |
| Visual Builder | ✅ | ✅ | ❌ | ✅ |
| User Code Execution | ❌ None | Yes (eval/sandbox) | N/A (library) | Scripts |
| Config-as-Code | Full JSON | Partial | ❌ | BPMN |
| MCP Support | 48 Tools | ❌ | ❌ | ❌ |
| Concurrency | Virtual threads | Event loop / GIL | Platform threads | Platform threads |
| Audit Trail | Cryptographic (HMAC) | Basic logging | DIY | Process history |
| Compliance | 15+ frameworks (EU AI Act, GDPR, HIPAA, etc.) | DIY | DIY | Partial |
| Management UI | ✅ (11 languages) | ✅ | ❌ | ✅ |
| Prometheus/Grafana | 45 panels | ❌ | DIY | ✅ |
| License | Apache 2.0 | Mixed (SEE/AGPL) | Apache 2.0 | Dual (CE/EE) |

## Getting Started

### Prerequisites
- Docker and Docker Compose
- A supported LLM API key (OpenAI, Anthropic, Google, or Ollama for local)

### Quickstart
1. Visit https://eddi.labs.ai/docs/install-wizard/ for the interactive Install Wizard
2. Or use Docker Compose directly:
   ```
   git clone https://github.com/labsai/EDDI.git
   cd EDDI
   docker compose up -d
   ```
3. Access EDDI Manager at http://localhost:7070
4. Access EDDI API at http://localhost:7071

### Configure an Agent
1. Open EDDI Manager → Create a new Bot
2. Add a Package with LLM Config (provider, model, temperature)
3. Add Rules, Output Sets, and HTTP Calls as needed
4. Deploy the Bot
5. Test via the side-panel chat

## Use Cases

- **Healthcare** — Patient intake agents, medical FAQ bots with HIPAA-compliant audit trails
- **Financial Services** — Customer support agents with compliance logging and fraud detection assistants
- **E-Commerce** — Product recommendation agents with multi-language support and intent-based routing
- **Manufacturing** — Equipment maintenance assistants running on-premises or in private clouds
- **Government** — Citizen inquiry agents in air-gapped environments with no cloud dependency
- **Developer Platforms** — Internal AI services integrating into CI/CD pipelines and code review workflows
- **Compliance & Regulated Industries** — Built-in support for 15+ regulatory frameworks (EU AI Act, GDPR, CCPA, HIPAA, PIPEDA, etc.)

## Links

- Website: https://eddi.labs.ai
- GitHub: https://github.com/labsai/EDDI
- Documentation: https://docs.labs.ai
- Docker Hub: https://hub.docker.com/r/labsai/eddi
- License: Apache 2.0