convez.ai
MCP ServerAutomaçãoAvançado
labsai

EDDI — Middleware de Orquestração Multi-Agente

labsai/EDDI

Orquestrador enterprise de agentes IA config-driven, sem código

Ver no GitHub
Muito bomPluginScore · de 0 a 100

Motor de IA acionado por configuração que transforma JSON em agentes de produção. Orquestra múltiplos agentes, suporta 12+ provedores LLM, protocolos MCP/A2A, RAG, memória persistente e conformidade empresarial (EU AI Act, GDPR, HIPAA). Construído em Java 25 com Quarkus.

Instalação

$npx convez-ai labsai/EDDI

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
393
Forks
132
Acompanhando
17
Saúde
87%
Último commit
há 1 dia
Versão
6.7.0
Issues abertas
102
Contribuidores
23

Casos de uso

  • Construir agentes conversacionais complexos sem escrever código
  • Orquestrar múltiplos agentes de IA para fluxos empresariais
  • Implementar sistemas de IA em conformidade com regulações (GDPR, HIPAA, EU AI Act)

Veredito

EDDI é uma plataforma madura (v6.1.0) e bem-auditada (OpenSSF, Codacy) para quem precisa de orquestração multi-agente enterprise-grade com compliance integrado. Exige familiaridade com JSON, Docker e arquiteturas distribuídas; a curva de aprendizado é real, mas o retorno é alto para casos complexos.

README

A tradução para o português deste README ainda está na fila.

EDDI Banner Image

E.D.D.I — Multi-Agent Orchestration Middleware for Conversational AI

OpenSSF Best Practices OpenSSF Scorecard Codacy Badge

CI CodeQL Tests Coverage

Docker Pulls Repository: AI Ready

E.D.D.I (Enhanced Dialog Driven Interface) is a production-grade, config-driven multi-agent orchestration middleware for conversational AI. It coordinates users, AI agents, and business systems through intelligent routing, persistent memory, and API orchestration — without writing code.

Built with Java 25 and Quarkus. Ships as a Red Hat-certified Docker image. Native support for MCP (Model Context Protocol), A2A (Agent-to-Agent), Slack, OpenAPI, and OAuth 2.0.

Latest version: 6.1.0 · Website · Documentation · License: Apache 2.0


📑 Table of Contents


🏁 Quick Start

The fastest way to get EDDI running is the one-command installer. It sets up EDDI + your choice of database via Docker Compose, deploys the Agent Father starter agent, and walks you through creating your first AI agent.

Linux / macOS / WSL2:

curl -fsSL https://raw.githubusercontent.com/labsai/EDDI/main/install.sh | bash

Windows (PowerShell):

Invoke-WebRequest -UseBasicParsing -Uri "https://raw.githubusercontent.com/labsai/EDDI/main/install.ps1" -OutFile "install.ps1"
Unblock-File .\install.ps1
.\install.ps1

Requires Docker. The wizard auto-generates a unique vault encryption key for secret management.

bash install.sh --defaults                 # All defaults, no prompts
bash install.sh --db=postgres --with-auth  # PostgreSQL + Keycloak
bash install.sh --full                     # Everything enabled (DB + auth + monitoring)
bash install.sh --local                    # Build Docker image from local source

The --local flag is for contributors testing pre-release builds:

./mvnw package -DskipTests    # Build the Java app
bash install.sh --local        # Build Docker image + start containers

🔄 Updating

The installer creates an eddi CLI wrapper that makes updating easy:

eddi update

This pulls the latest Docker image from the registry and restarts the containers. It works even when the same tag (e.g. latest) was re-published — Docker always checks the remote digest for changes.

eddi command not found? The CLI lives at ~/.eddi/eddi (Linux/macOS) or ~/.eddi/eddi.cmd (Windows). Either restart your terminal so the PATH takes effect, or use the full path:

# Linux / macOS
~/.eddi/eddi update

# Windows (PowerShell)
& "$HOME\.eddi\eddi.cmd" update

If the eddi CLI isn't available, run the equivalent docker commands from your install directory (~/.eddi by default):

cd ~/.eddi
docker compose --env-file .env -f docker-compose.yml pull
docker compose --env-file .env -f docker-compose.yml up -d

Adjust the -f flags to match your setup (e.g. add -f docker-compose.auth.yml if using Keycloak).

🐳 Docker Compose (Manual)

If you prefer manual control over Docker Compose:

# Default (EDDI + MongoDB)
docker compose up

# PostgreSQL instead of MongoDB
EDDI_DATASTORE_TYPE=postgres docker compose -f docker-compose.yml -f docker-compose.postgres.yml up

# With Keycloak authentication
docker compose -f docker-compose.yml -f docker-compose.auth.yml up

# With Prometheus + Grafana monitoring
docker compose -f docker-compose.yml -f docker-compose.monitoring.yml up

# Full stack (all overlays)
docker compose -f docker-compose.yml -f docker-compose.auth.yml \
  -f docker-compose.monitoring.yml -f docker-compose.nats.yml up

Available compose overlays: docker-compose.auth.yml (Keycloak), docker-compose.monitoring.yml (Prometheus+Grafana), docker-compose.nats.yml (NATS JetStream), docker-compose.postgres.yml / docker-compose.postgres-only.yml, docker-compose.local.yml (build from source).

docker pull labsai/eddi    # Pull latest from Docker Hub

→ hub.docker.com/r/labsai/eddi


💡 Why EDDI?

Most multi-agent frameworks (LangGraph, CrewAI, AutoGen) are Python/Node libraries — great for prototyping, hard to govern in production. EDDI approaches from the opposite direction: a deterministic engine built to safely govern non-deterministic AI.

DimensionTypical Python/Node FrameworksEDDI
ConcurrencyGIL or single-threaded event loopJava 25 Virtual Threads — true OS-level parallelism
Agent LogicEmbedded in application codeVersioned JSON configurations — update behavior without redeployment
Security ModelOften relies on sandboxed code executionNo dynamic code execution at all; envelope-encrypted vault, SSRF protection
ComplianceRequires custom implementationGDPR, HIPAA, EU AI Act infrastructure built-in
Audit TrailApplication-level loggingHMAC-SHA256 immutable ledger with cryptographic agent signing
Deploymentpip/npm + manual infrastructureOne-command Docker install, Kubernetes/OpenShift-ready

"The engine is strict so the AI can be creative." — Project Philosophy


📸 See It In Action


✨ Features

🤖 Multi-Agent Orchestration

  • 🔀 Intelligent Routing — Direct conversations to different agents based on context, rules, and intent
  • 🗣️ Group Conversations — Multi-agent debates with 5 built-in discussion styles: Round Table, Peer Review, Devil's Advocate, Delphi, and Debate
  • 💬 Slack Integration — Deploy agents to Slack channels and run multi-agent debates directly in threads
  • 🪆 Nested Groups — Compose groups of groups for tournament brackets, red-team vs blue-team, and panel reviews
  • 👥 Managed Conversations — Intent-based auto-routing with one conversation per user per intent
  • 🎯 Capability Matching — Discover and route to agents by skill, confidence score, and custom attributes
  • 🧙 Agent Father — Meta-agent that creates other agents through conversation (ships out of the box)

🧠 LLM Provider Support (12 Providers)

CategoryProviders
Cloud APIsOpenAI · Anthropic Claude · Google Gemini · Mistral AI
Enterprise CloudAzure OpenAI · Amazon Bedrock · Oracle GenAI · Google Vertex AI
Self-HostedOllama · Jlama · Hugging Face
CompatibleAny OpenAI-compatible endpoint (DeepSeek, Cohere, etc.) via baseUrl

🔗 Standards & Interoperability

EDDI implements open standards — not proprietary APIs:

StandardRoleWhat It Enables
MCP (Model Context Protocol)Server (42 tools) + ClientControl EDDI from Claude Desktop, Cursor, or any MCP client. Connect agents to external MCP tool servers
A2A (Agent-to-Agent Protocol)Full implementationCross-platform agent communication, Agent Cards, and skill discovery
OpenAPI 3.1Native generation + consumptionAuto-generated spec. Paste any OpenAPI spec → get a fully deployed API-calling agent
OAuth 2.0 / OIDCKeycloak integrationAuthentication, authorization, and multi-tenant isolation
SSE (Server-Sent Events)Streaming transportReal-time chat responses, group discussion feeds, and live log streaming

💭 Memory & Context Management

  • 💾 Persistent User Memory — Agents remember facts, preferences, and context across conversations via structured key-value entries with visibility scoping (global, agent, group)
  • 🧠 LLM Memory Tools — Built-in tools agents can call to read, write, and search their own persistent memory
  • 💤 Dream Consolidation — Background memory maintenance: stale entry pruning, contradiction detection, and fact summarization (inspired by Anthropic's research on background memory consolidation)
  • 🪟 Token-Aware Windowing — Intelligent context packing with model-specific tokenizer support and anchored opening steps
  • 📝 Rolling Summary — Incremental LLM-powered summarization of older turns with a Conversation Recall Tool for drill-back into compressed history
  • 🔧 Property Extraction — Config-driven slot-filling with longTerm / conversation / step scoping — EDDI's importance extraction mechanism
  • 🛡️ Memory Policy (Commit Flags) — Strict write discipline marks failed task output as uncommitted (hidden from LLM context) and injects concise error digests for graceful degradation
  • 🔄 Conversation State — Full history with undo/redo support

📚 RAG (Retrieval-Augmented Generation)

  • 📦 7 Embedding Providers — OpenAI, Ollama, Azure OpenAI, Mistral, Bedrock, Cohere, Vertex AI
  • 🗄️ 5 Vector Stores — pgvector, In-Memory, MongoDB Atlas, Elasticsearch, Qdrant
  • 🌐 httpCall RAG — Zero-infrastructure RAG via any search API (BM25, Elasticsearch, custom)
  • 📥 REST Ingestion API — Async document ingestion with status tracking

🛠️ Built-In AI Agent Tools

ToolDescription
🔍 Web SearchDuckDuckGo or Google Custom Search
🧮 CalculatorSandboxed recursive-descent math parser (no eval(), no code injection)
🌐 Web ScraperSSRF-protected content extraction from web pages
📄 PDF ReaderSSRF-protected document extraction
☁️ Weather · 🕐 DateTimeReal-time data tools
📊 Data Formatter · 📝 Text SummarizerData transformation tools
🔌 HTTP Calls as ToolsExpose your own REST APIs as LLM-callable tools with full security sandboxing
🧠 User MemoryRead/write/search persistent user memory
🔙 Conversation RecallDrill back into summarized conversation history
📎 Multimodal AttachmentsImage, PDF, audio, and video input with MIME-based routing

⏰ Scheduled Execution & Heartbeats

  • 🫀 Heartbeat Triggers — Periodic agent wake-ups at configurable intervals for proactive behavior (inspired by OpenClaw's heartbeat architecture)
  • ⏲️ Cron Scheduling — Standard cron expressions for timed agent execution
  • 🔄 Conversation Strategies — persistent (reuse same conversation across fires) or new (fresh context each time)
  • 📊 Fire Logging — Complete execution history with status, duration, cost tracking, and retry logic
  • 🌙 Dream Cycles — Scheduled background memory consolidation with cost ceilings per run

📈 Smart Model Cascading

  • 📉 Cost Optimization — Try cheap/fast models first, escalate to powerful models only when confidence is low
  • 📊 4 Confidence Strategies — Structured output, heuristic, judge model, or none
  • 💰 Per-Conversation Budgets — Automatic cost tracking with budget caps and eviction
  • 🏢 Tenant Cost Ceilings — Monthly cost budgets per tenant with automatic enforcement

🔐 Enterprise Security & Compliance

  • 🏦 Secrets Vault — Envelope encryption (PBKDF2 + AES-256) with tenant-scoped DEK/KEK rotation. Never plaintext in DB
  • 🛡️ SSRF Protection — All tools validate URLs against private IPs, internal hostnames, and non-HTTP schemes before any request
  • 🔒 Sandboxed Evaluation — Recursive-descent math parser only. No eval(), no script engines, no reflection-based execution
  • 🔑 OAuth 2.0 / Keycloak — Multi-tenant authentication, authorization, and role-based access control
  • ✍️ Agent Signing — Ed25519 cryptographic identity per agent; audit entries signed with agent private keys
  • 🚫 No Dynamic Code Execution — Custom logic runs in external MCP servers, outside the EDDI security perimeter
RegulationEDDI Support
EU AI ActImmutable HMAC-SHA256 audit ledger, decision traceability, risk classification guidance
GDPRCascading data erasure (Art. 17), data portability (Art. 15/20), restriction of processing (Art. 18), per-category retention, pseudonymization
CCPARight to delete, right to know, data portability
HIPAADeployment guide, BAA template, LLM provider BAA matrix, session timeout guidance
InternationalPIPEDA 🇨🇦 · LGPD 🇧🇷 · APPI 🇯🇵 · POPIA 🇿🇦 · PDPA 🇸🇬🇹🇭🇲🇾 · PIPL 🇨🇳 compatibility documented
  • 📜 Audit Ledger — Every agent decision recorded in a write-once, HMAC-secured, append-only ledger
  • 🔍 Compliance Startup Checks — Advisory warnings on boot for TLS and database encryption gaps
  • 🗑️ GDPR Orchestration — One-call cascading erasure across 6 stores + audit trail pseudonymization
  • 📤 Data Portability — Complete user data export (memories, conversations, audit entries) via REST and MCP

⚙️ Configuration-Driven Architecture

  • 📄 JSON Configs, Not Code — Agent behavior defined in versioned, diffable JSON documents
  • 🔧 Lifecycle Pipeline — Pluggable task pipeline: Input → Parse → Rules → API/LLM → Output
  • 📦 Composable Agents — Agents assembled from reusable, version-controlled workflows and extensions
  • 🧪 Behavior Rules — IF-THEN logic engine for routing, orchestration, and business logic
  • 📤 Import / Export — Agents portable as ZIP files with automatic secret scrubbing on export
  • 🔄 Agent Sync — Live instance-to-instance sync with structural matching, content diffing, and selective resource picking — no ZIP intermediary needed
  • 📝 Prompt Snippets — Reusable, versioned system prompt building blocks available as {{snippets.safety_rules}}
  • 📎 Content Type Routing — MIME-based behavior rule conditions for multimodal attachment routing

🚀 Cloud-Native & Observable

  • 🐳 One-Command Install — Interactive wizard sets up EDDI + database + starter agent via Docker
  • ☸️ Kubernetes / OpenShift — Kustomize overlays, Helm charts, HPA, PDB, NetworkPolicy
  • 📊 Prometheus & Grafana — 50+ Micrometer metrics at /q/metrics (tools, vault, memory, scheduling, conversations). Pre-built Grafana dashboard included
  • 🔭 OpenTelemetry Tracing — Per-task distributed traces via OTLP (Jaeger, Tempo, Datadog). Every pipeline task emits spans with task.id, task.type, conversation.id, and agent.id
  • 🩺 Health Checks — Liveness & readiness probes at /q/health/live and /q/health/ready
  • 🔄 NATS JetStream — Async event bus for distributed processing
  • ⚡ Virtual Threads — Java 25 virtual threads for true OS-level concurrency (no Python GIL or Node.js event loop bottleneck)
  • 🗃️ DB-Agnostic — Choose MongoDB or PostgreSQL; switch with one env var. Single Docker image for both
  • 🏗️ Red Hat Certified — Container certification with automated preflight checks in CI/CD

📖 Monitoring Guide: See docs/monitoring/monitoring-guide.md for architecture overview, metrics reference, alerting rules, and a production checklist.

🖥️ Manager Dashboard & Chat UI

  • 🎨 React 19 Manager — Modern admin dashboard for agent building, testing, deployment, and monitoring
  • 💬 Chat Widget — Embeddable React chat UI with SSE streaming and Keycloak auth
  • 🔍 Audit Trail Viewer — Timeline-based compliance and debugging UI
  • 📋 Logs Panel — Live SSE log streaming + searchable history
  • 🔑 Secrets Manager — Write-only vault UI with copy-reference support
  • 🌍 11 Languages — English, German, Spanish, French, Portuguese, Chinese, Japanese, Korean, Arabic (RTL), Hindi, Thai

🧩 Quarkus SDK

Building a Quarkus app that talks to EDDI? Use the quarkus-eddi extension:

<dependency>
    <groupId>io.quarkiverse.eddi</groupId>
    <artifactId>quarkus-eddi</artifactId>
    <version>6.1.0</version>
</dependency>
@Inject EddiClient eddi;

String answer = eddi.chat("my-agent", "Hello!");

Features: Dev Services (auto-starts EDDI in dev mode), fluent API, SSE streaming, @EddiAgent endpoint wiring, @EddiTool MCP bridge. See the quarkus-eddi README for full docs.


📖 Documentation

GuideDescription
Getting StartedSetup and first steps
Developer QuickstartBuild your first agent in 5 minutes
ArchitectureDeep dive into EDDI's design and pipeline
LLM ConfigurationConnecting to 12 LLM providers
Behavior RulesConfiguring agent routing logic
HTTP CallsExternal API integration
RAGKnowledge base retrieval setup
MCP Server42 tools for AI-assisted agent management
A2A ProtocolAgent-to-Agent peer communication
Slack IntegrationDeploy agents to Slack and run group discussions
Group ConversationsMulti-agent debate orchestration
User MemoryCross-conversation fact retention
Memory PolicyCommit flags and strict write discipline
Model CascadingCost-optimized multi-model routing
Scheduling & HeartbeatsCron schedules, heartbeats, dream consolidation
Agent SyncLive instance-to-instance sync and upgrade imports
Import / ExportZIP-based agent portability and merge
Prompt SnippetsReusable system prompt building blocks
AttachmentsMultimodal attachment pipeline
Capability MatchingA2A skill discovery and routing
SecuritySSRF protection, sandboxing, and hardening
Secrets VaultEnvelope encryption and auto-vaulting
Audit LedgerEU AI Act-compliant audit trail
KubernetesDeploy with Kustomize or Helm
Monitoring & TracingPrometheus, Grafana, OpenTelemetry, alerting
Red Hat & OpenShiftRHEL support, certified container, automated release
Agent Father Deep DiveHow the meta-agent works
Full DocumentationComplete documentation site

📋 Compliance & Privacy

EDDI provides built-in infrastructure for regulatory compliance:

GuideCovers
GDPR / CCPAData erasure, export, Art. 18 restriction of processing, per-category retention, and consent guidance
HIPAAHealthcare deployment guide — encryption, BAAs, LLM provider matrix, session management
EU AI ActAI risk classification, decision traceability, immutable audit ledger
Privacy & Data ProcessingData flows, LLM provider matrix, international regulations (PIPEDA, LGPD, APPI, POPIA, PDPA, PIPL)
Compliance Data FlowSingle-page data flow diagram for auditors
Incident ResponseBreach response runbook (GDPR 72h, CCPA 45 days, HIPAA 60 days)

🏗️ Development

Prerequisites

ToolVersionNotes
Java (JDK)25Eclipse Temurin recommended
Maven3.9+Bundled via mvnw / mvnw.cmd wrapper — no install needed
MongoDB6.0+Local instance or Docker (docker run -d -p 27017:27017 mongo:7)
DockerLatestFor integration tests and container builds

Windows users: Replace ./mvnw with .\mvnw.cmd in all commands below.

Quarkus Dev Mode

Dev mode starts the application with live reload — code changes are picked up automatically without restarting:

# Linux / macOS
./mvnw compile quarkus:dev

# Windows (PowerShell)
.\mvnw.cmd compile quarkus:dev

Then open http://localhost:7070. The Quarkus Dev UI is available at http://localhost:7070/q/dev.

Dev mode also enables:

  • Continuous testing — press r in the terminal to re-run tests on changes
  • Dev UI — browse endpoints, CDI beans, configuration, and health checks
  • Live reload — Java and resource changes apply instantly

💡 Secrets Vault: To use the secrets vault (storing API keys encrypted), set the master key before starting:

# Linux/macOS
export EDDI_VAULT_MASTER_KEY=my-dev-passphrase

# Windows (PowerShell)
$env:EDDI_VAULT_MASTER_KEY = "my-dev-passphrase"

# Or in a .env file (already in .gitignore)
echo "EDDI_VAULT_MASTER_KEY=my-dev-passphrase" > .env

Without this, the vault is disabled and secret management returns HTTP 503. Any passphrase works for local development. See Secrets Vault for production setup.

Maven Command Reference

CommandWhat It Does
./mvnw compile quarkus:devStart dev mode with live reload (port 7070)
./mvnw compileCompile sources only (fast feedback)
./mvnw clean compileClean build — delete target/ and recompile from scratch
./mvnw testRun unit tests (excludes *IT.java integration tests)
./mvnw verify -DskipITsCompile + unit tests + package (no integration tests)
./mvnw verifyFull build — compile + unit tests + integration tests (requires Docker)
./mvnw validateRun Checkstyle code style checks
./mvnw formatter:formatAuto-format Java sources using the project Eclipse formatter
./mvnw package -DskipTestsBuild the JAR without running tests (for install.sh --local)
./mvnw clean package '-Dquarkus.container-image.build=true'Build the app + Docker image
./mvnw package -Plicense-gen -DskipTestsGenerate third-party licenses (Red Hat certification)
./mvnw quarkus:dev -DsuspendStart dev mode and wait for debugger on port 5005
./mvnw quarkus:dev -Ddebug=falseStart dev mode without the debug agent

JaCoCo is configured to run automatically during ./mvnw test. After tests complete, find the coverage report at:

target/site/jacoco/index.html
PropertyDefaultDescription
-Dquarkus.http.port=<port>7070Override the HTTP port
-Dquarkus.mongodb.connection-string=<uri>mongodb://localhost:27017MongoDB connection
-Dquarkus.profile=<profile>devActive Quarkus profile (dev, test, prod)
-DskipTestsfalseSkip all tests
-DskipITstrueSkip integration tests only

Build & Docker

# Build app + Docker image
./mvnw clean package '-Dquarkus.container-image.build=true'

# Build without container (for install.sh --local)
./mvnw package -DskipTests

# Generate third-party licenses (Red Hat certification)
./mvnw package -Plicense-gen -DskipTests

☸️ Kubernetes

# Quickstart (one-file deployment)
kubectl apply -f https://raw.githubusercontent.com/labsai/EDDI/main/k8s/quickstart.yaml

# Kustomize overlays
kubectl apply -k k8s/overlays/mongodb/     # MongoDB backend
kubectl apply -k k8s/overlays/postgres/    # PostgreSQL backend

# Helm
helm install eddi ./helm/eddi --namespace eddi --create-namespace

Includes overlays for auth (Keycloak), monitoring (Prometheus/Grafana), NATS messaging, Ingress, and production hardening (HPA, PDB, NetworkPolicy). See the Kubernetes Guide for details.


🤝 Contributing

We welcome contributions! Please read our Contributing Guide for details on setting up your development environment, code style, commit conventions, and the pull request process.

Every PR is automatically checked by CI (build + tests), CodeQL (security), dependency review, and AI-powered code review.

🔒 Security

EDDI ships with security-by-default for production deployments:

  • Authentication enforced — AuthStartupGuard fails startup if OIDC is disabled in production without explicit opt-out
  • Secrets encrypted at rest — Envelope encryption (PBKDF2 → AES-256-GCM) with per-deployment salt. Never plaintext in DB
  • SSRF protection — All LLM tool HTTP calls go through SafeHttpClient with private IP blocking, redirect validation, and scheme enforcement
  • Security headers — X-Content-Type-Options, X-Frame-Options, Content-Security-Policy configured out of the box
  • CI/CD security gates — Every push/PR is scanned by:
    • CodeQL — Semantic SAST analysis with security-extended queries
    • Trivy — CVE scanning for both filesystem dependencies and Docker images (blocking on CRITICAL/HIGH)
    • Gitleaks — Git history scanning to prevent secret/credential leakage
    • ZAP — DAST API scanning against the live Docker image (report-only)
    • CycloneDX — SBOM generation for supply chain transparency
    • Jazzer — Coverage-guided fuzz testing for security-critical parsers (PathNavigator, MatchingUtilities)
    • All actions SHA-pinned to prevent supply-chain attacks

For vulnerability reports, see our Security Policy. For architecture details, see Security Architecture.

📜 Code of Conduct

This project follows the Contributor Covenant Code of Conduct.

Ver o original no GitHub

Bom para

Relacionados