# EDDI — Enterprise AI Orchestrator

> EDDI is a configuration-driven AI orchestration middleware built natively on the JVM (Java 25). Currently in v6, latest release 6.4.0. Apache 2.0 licensed. Website: https://eddi.technology | 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
- Dedicated resource editors: Rules, LLM Config, Output Sets, HTTP Calls, Workflows, Prompt Templates, Properties, Agent Configuration
- Platform Operator (/manage/operator): a meta-agent that creates and changes agents in conversation, with every write behind a human approval gate; plus a form-based agent wizard (/manage/agents/wizard)
- Workspaces: space switcher, share dialog for any resource type, ownership badges, actions limited to the caller's access level
- Connections: list, creation wizard, detail editor, and a linked-accounts panel for per-user OAuth
- Approvals inbox that decides tool-call pauses in place
- 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
- 84 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; stdio-only MCP servers are reachable through a sidecar bridge
- OpenAPI 3.1 — Auto-generated spec; paste external specs to create API-calling agents
- A2A (Agent-to-Agent Protocol) for cross-platform agent communication
- OAuth 2.0 / OIDC via Keycloak and SSE for real-time streaming, including token-by-token output while tools run
- OpenAI-compatible /v1 API (disabled by default): deployed agents appear as models to Open WebUI, the openai SDK, LangChain, and LiteLLM
- Caller identity: an HTTP call can send the signed-in user's token to the same origin via ${caller:token}
- EDDI's own documentation is readable by agents over MCP (list_docs, read_docs) and REST (GET /administration/docs)

### 12 Built-In Agent Tools
- Web Search (DuckDuckGo, Google Custom Search)
- Calculator (sandboxed math parser, no eval())
- Web Scraper (SSRF-protected content extraction)
- PDF Reader (SSRF-protected document extraction)
- Weather (real-time weather data)
- DateTime (current date and time)
- Data Formatter (structured data transformation)
- Text Summarizer (LLM-powered summarization)
- HTTP Calls (expose REST APIs as LLM tools)
- User Memory (read/write/search persistent memory)
- Conversation Recall (dive into summarized history)
- Multimodal Input (image, PDF, audio, video via MIME routing)

### Multi-Agent Orchestration
- Coordinator pattern and intent-based discovery for routing conversations to specialist agents
- Agents can delegate to other agents within the same EDDI instance
- Group conversations with 7 built-in discussion styles: Round Table, Peer Review, Devil's Advocate, Delphi, Debate, Task Force, Negotiation (plus custom phases)
- Voting phases (majority or approval, weighted, quorum-gated) that record a decision with the full tally and dissents
- Shared artifacts co-edited by members, bid-based task assignment, and an agent-writable group task list
- Standing teams with a backlog and cron cadences, a facilitator with bounded moves, and retro phases that harvest team memory
- Humans as group members who take a real turn in the discussion
- Five preset templates: research pod, editorial team, ops task force, decision board, negotiation table
- Nested groups, runtime recruitment of specialist agents, and group cost ceilings

### 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
- Dream consolidation — background memory maintenance on configurable schedules
- Memory Policy (Commit Flags) — strict write discipline for failed task output
- Rolling summarization with conversation recall tool

### Config & Portability
- Import/Export — agents as ZIP files with automatic secret scrubbing
- Agent Sync — live instance-to-instance sync with structural matching and content diffing
- Prompt Snippets — reusable system prompt building blocks (`{{snippets.name}}`)
- Behavior Rules — IF-THEN logic engine for routing and business logic

### 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; cloud metadata endpoints are always refused
- PII-safe logging with SHA-256 pseudonymization; console output is redacted before any handler sees it
- Human-in-the-loop approval gates at turn, tool-call, and group-phase level, with timeout policies, Slack and MCP approvals, and crash recovery
- Per-user workspaces (eddi.workspaces.enabled): every resource has an owner, a space (user or Keycloak team), a visibility, and grants at USE, VIEW, EDIT, or OWN level
- Connections: one credential model for HTTP calls, MCP servers, and A2A peers (static or basic keys from the vault, OAuth2 client credentials, per-user OAuth2 authorization code with PKCE, or a caller-supplied credential that is never stored)
- Tool results from every source carry a provenance envelope, and a configurable guardrail marks, redacts, warns on, or blocks directive-shaped text

### 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
- Grafana operations dashboard (auto-provisioned) and a Full Metrics Reference dashboard with a panel for every registered meter
- OpenTelemetry tracing via OTLP
- 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), plus overlays for Ollama, monitoring, auth, NATS, Chroma, Open WebUI, and an MCP stdio sidecar
- Kubernetes via Helm chart 2.0.0 and Kustomize manifests
- Supports MongoDB OR PostgreSQL as backend database
- Optional NATS messaging for event-driven architectures
- Production image on Red Hat UBI 10 (openjdk-25-runtime, digest-pinned); requires an x86-64-v3 CPU (Intel Haswell / AMD Excavator or newer)
- Red Hat container certified; stable releases are also published to the Red Hat certified catalog (registry.connect.redhat.com)

## 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
- **Agent**: top-level deployable unit that references one or more workflows
- **Workflow**: versioned pipeline of extensions (rules, LLM tasks, HTTP calls, output, properties)
- **Groups**: multi-agent discussion configurations
- **Connections**: how to authenticate to one external system, referenced as ${connection:name}
- **Conversations**: stateful interaction sessions with memory

### LLM Integration
Supports 12 providers simultaneously:
- **Cloud APIs**: OpenAI, Anthropic Claude, Google Gemini, Mistral AI
- **Enterprise Cloud**: Azure OpenAI, Amazon Bedrock, Oracle GenAI, Google Vertex AI
- **Self-Hosted**: Ollama (local models), Jlama, Hugging Face
- **Compatible**: Any OpenAI-compatible endpoint (DeepSeek, Cohere, etc.) via baseUrl

## API

### REST API
Full CRUD operations for all resources (selection):
- `/agentstore/agents`: agent configurations
- `/workflowstore/workflows`: workflow pipelines
- `/rulestore/rulesets`, `/dictionarystore/dictionaries`: behavior rules and dictionaries
- `/llmstore/llms`, `/apicallstore/apicalls`, `/mcpcallsstore/mcpcalls`, `/ragstore/rags`: LLM, HTTP call, MCP call, and RAG configurations
- `/outputstore/outputsets`, `/propertysetterstore/propertysetters`, `/snippetstore/snippets`: output, property, and prompt snippet configurations
- `/groupstore/groups`, `/groupstore/templates`: group discussions and preset templates
- `/connectionstore/connections`: connections to external systems
- `/schedulestore/schedules`, `/channelstore/channels`: schedules and channel integrations
- `/secretstore/secrets`: secrets vault
- `/conversationstore/conversations`, `/usermemorystore/memories`: conversations and persistent user memory
- `/administration/agents/setup`: create a complete agent in one call

### MCP Tools (84 total)
Organized by domain:
- Conversation tools (13): chat, conversations, history, pipeline logs, audit trail, agent discovery, managed chat
- Admin tools (29): deploy/undeploy, agents, resources, triggers, schedules, channel integrations
- Group tools (18): group discussions, templates, follow-ups, standing-team backlogs
- Human-in-the-loop tools (10): pending approvals, resume/cancel, group phase approval, human member input
- Memory tools (8), Setup tools (2: setup_agent, create_api_agent), GDPR tools (2), Documentation tools (2)

### Quarkus SDK
- Quarkiverse extension: `quarkus-eddi`
- Dev Services (auto-starts EDDI in dev mode)
- Fluent API, SSE streaming, `@EddiAgent` endpoint wiring, `@EddiTool` MCP bridge

## 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 | 84 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 | ✅ Auto-provisioned | ❌ | DIY | ✅ |
| License | Apache 2.0 | Mixed (SEE/AGPL) | Apache 2.0 | Dual (CE/EE) |

## Getting Started

### Prerequisites
- Docker and Docker Compose (on x86-64 hosts, an x86-64-v3 CPU)
- A supported LLM API key (OpenAI, Anthropic, Google, or Ollama for local)

### Quickstart
1. One-command installer (Linux / macOS / WSL2): `curl -fsSL https://raw.githubusercontent.com/labsai/EDDI/main/install.sh | bash`
2. Or use Docker Compose directly:
   ```
   git clone https://github.com/labsai/EDDI.git
   cd EDDI
   docker compose up -d
   ```
   Add `-f docker-compose.ollama.yml` to run a local Ollama alongside EDDI.
3. Open the EDDI Manager and the REST API at http://localhost:7070 (MCP endpoint: http://localhost:7070/mcp)
4. Developer Quickstart: https://docs.labs.ai/getting-started/developer-quickstart.md

### Configure an Agent
A fresh install starts with no agents deployed. Any of these creates the first one:
1. Platform Operator: open http://localhost:7070/manage/operator and describe the agent; every write waits for your approval
2. Agent wizard: http://localhost:7070/manage/agents/wizard
3. One API call: `setup_agent` over MCP, or `POST /administration/agents/setup` with agentName, systemPrompt, provider, model, and an apiKey such as `${vault:my-key}`
4. Test via the side-panel chat, or `chat_with_agent` over MCP

## 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.technology
- GitHub: https://github.com/labsai/EDDI
- Documentation: https://docs.labs.ai
- Docker Hub: https://hub.docker.com/r/labsai/eddi
- License: Apache 2.0