AADE — AI Assistant DevOps Engineer

A multi-agent AI system that analyzes production log files, investigates root causes, and generates step-by-step remediation plans — powered by three specialized AI agents working in a sequential pipeline with real-time streaming updates.

Demo

Recording.2026-04-20.120410.mp4

---

Screenshots

Upload Interface

The landing page with drag-and-drop file upload — accepts .log and .txt files up to 1MB.

Real-Time Agent Progress (SSE Streaming)

Watch each agent work in real-time. The browser receives Server-Sent Events as each agent starts and completes.

Analysis Results — Three Tabs

Log Analysis — Detailed breakdown of errors, timeline, and root cause:

Investigation Report — Similar issues, documentation references, and ranked causes:

Solution Plan — Step-by-step commands, verification, and rollback procedures:

History Sidebar

All past analyses are persisted and accessible from the sidebar. Click any entry to reload its results.

---

What It Does

Upload a DevOps log file (Kubernetes failures, database errors, deployment crashes, etc.) and AADE runs a 3-agent AI pipeline:

1. Log Analyzer — Reads the log file using a tool-equipped agent, identifies errors, warnings, failure timelines, and root causes.
2. Issue Investigator — Takes the analysis and researches the problem — finding similar issues, documentation references, and community-verified solutions.
3. Solution Specialist — Synthesizes everything into an actionable remediation plan with step-by-step commands, verification steps, rollback procedures, and prevention strategies.

Each agent runs sequentially, passing its output to the next. The browser receives real-time progress updates via Server-Sent Events (SSE) as each agent starts and completes.

---

System Architecture

┌────────────────────────────────────────────────────────────┐
│                        BROWSER                             │
│                                                            │
│  ┌──────────┐   ┌──────────────┐   ┌───────────────────┐   │
│  │  Upload  │──>│  SSE Stream  │──>│  Results (3 Tabs) │   │
│  │  (.log)  │   │  EventSource │   │  react-markdown   │   │
│  └──────────┘   └──────┬───────┘   └───────────────────┘   │
└─────────────────────────┼──────────────────────────────────┘
                          │ GET /api/analyze/{id}/stream
                          ▼
┌─────────────────────────────────────────────────────────────┐
│                   SPRING BOOT BACKEND                       │
│                                                             │
│  ┌─────────────────────┐    ┌───────────────────────────┐   │
│  │ AnalysisController  │───>│  AnalysisServiceImpl      │   │
│  │ (REST + SSE)        │    │  (Pipeline Orchestration) │   │
│  └─────────────────────┘    └───────────┬───────────────┘   │
│                                         │                   │
│                    ┌────────────────────┼──────────────┐    │
│                    ▼                    ▼              ▼    │
│            ┌──────────────┐  ┌───────────────┐ ┌──────────┐ │
│            │ LogAnalyzer  │  │  Issue        │ │ Solution │ │
│            │ Agent        │  │  Investigator │ │ Specialist │
│            │ + LogReader  │  │  Agent        │ │ Agent    │ │
│            │   Tool       │  │               │ │          │ │
│            └──────┬───────┘  └───────┬───────┘ └────┬─────┘ │
│                   │                  │              │       │
│                   └────────┬─────────┘              │       │
│                            ▼                        ▼       │
│                    ┌──────────────────────────────────┐     │
│                    │     Azure OpenAI (GPT-4)         │     │
│                    └──────────────────────────────────┘     │
│                                                             │
│  ┌──────────────────────────────────────────────────────┐   │
│  │  LocalStorageService (File-based persistence)        │   │
│  │  data/{chatId}/metadata.json, input.log, *.md        │   │
│  └──────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘

Request Flow

1. POST /api/analyze          → Upload file, get chatId
2. GET  /api/analyze/{id}/stream → SSE connection opens
   ├── event: AGENT_START     → "Log Analyzer is reading your log file..."
   ├── event: AGENT_COMPLETE  → "Log Analyzer — Complete"
   ├── event: AGENT_START     → "Issue Investigator is researching..."
   ├── event: AGENT_COMPLETE  → "Issue Investigator — Complete"
   ├── event: AGENT_START     → "Solution Specialist is building a plan..."
   ├── event: AGENT_COMPLETE  → "Solution Specialist — Complete"
   └── event: PIPELINE_COMPLETE → "Analysis Complete!"
3. GET  /api/analyze/{id}/results → Full results JSON (3 markdown reports)
4. GET  /api/analyses              → History list

---

Technologies Used

Backend

Technology	Version	Purpose
Java	21	Language runtime (records, text blocks, pattern matching)
Spring Boot	4.0.5	Web framework, dependency injection, auto-configuration
Spring Web (SseEmitter)	—	Server-Sent Events for real-time streaming to browser
LangChain4j	1.0.0-beta3	AI Services pattern — declarative AI agent interfaces with @SystemMessage, @UserMessage, @Tool
Azure OpenAI	GPT-4	LLM provider for all three agents
Jackson	—	JSON serialization for SSE payloads and metadata persistence
Maven	—	Build tool with wrapper (mvnw)

Frontend

Technology	Version	Purpose
React	19	Component-based UI
TypeScript	6	Type-safe JavaScript
Vite	8	Build tool with dev server proxy (/api → backend)
Tailwind CSS	3	Utility-first styling
react-markdown	10	Render agent outputs as formatted Markdown
remark-gfm	4	GitHub Flavored Markdown (tables, task lists)
Lucide React	—	Icon library
EventSource API	—	Browser-native SSE client

Design Patterns & Principles

Concept	Implementation
SOLID — Single Responsibility	Controller handles HTTP only. Service handles pipeline logic. Storage handles file I/O. Each config class has one concern.
SOLID — Open/Closed	StorageService interface — swap LocalStorageService for cloud storage without changing AnalysisServiceImpl
SOLID — Liskov Substitution	Any StorageService implementation is interchangeable
SOLID — Interface Segregation	StorageService and AnalysisService are separate interfaces with focused methods
SOLID — Dependency Inversion	Services depend on ChatLanguageModel (interface), not AzureOpenAiChatModel (concrete). All injected via constructor.
Server-Sent Events (SSE)	One-way server-to-client streaming over HTTP. SseEmitter keeps connection open; async thread pushes progress events. Browser's EventSource API auto-handles reconnection.
AI Services Pattern (LangChain4j)	Agents defined as Java interfaces with prompt annotations. LangChain4j generates implementations at runtime via dynamic proxy. No boilerplate.
Sequential Pipeline	Agent outputs chain: Log Analysis → Investigation → Solution. Each agent builds on the previous agent's work.
Async Execution	Pipeline runs on a dedicated ThreadPoolTaskExecutor, freeing Tomcat threads for other requests
File-Based Persistence	Each analysis stored in data/{chatId}/

---

Folder Structure

AADE/
├── .env                                    # Shared env vars (gitignored)
├── .gitignore
├── docker-compose.yml
├── README.md
├── dummy_logs/                             # Sample log files for testing
│   ├── kubernetes_deployment_error.log
│   └── database_connection_error.log
│
├── backend/                                # Spring Boot 4 + Java 21
│   ├── .env                                # Azure OpenAI credentials (gitignored)
│   ├── .gitignore
│   ├── pom.xml
│   ├── mvnw / mvnw.cmd                    # Maven wrapper
│   ├── Dockerfile
│   └── src/main/java/org/AI/multiagentdevopsengineer/
│       ├── AadeApplication.java            # Entry point (conditional SSL fix)
│       │
│       ├── config/
│       │   ├── ModelConfig.java            # @Bean ChatLanguageModel (Azure OpenAI)
│       │   ├── AgentConfig.java            # @Bean for 3 AI agent proxies
│       │   ├── AsyncConfig.java            # ThreadPoolTaskExecutor for pipeline
│       │   └── CorsConfig.java             # CORS for frontend dev server
│       │
│       ├── controller/
│       │   └── AnalysisController.java     # REST endpoints + file validation
│       │
│       ├── service/
│       │   ├── AnalysisService.java        # Interface
│       │   ├── AnalysisServiceImpl.java    # Pipeline orchestration + SSE
│       │   ├── StorageService.java         # Interface (DIP)
│       │   └── LocalStorageService.java    # File-based implementation
│       │
│       ├── model/
│       │   ├── AnalysisMetadata.java       # Record: chatId, fileName, status
│       │   ├── AnalysisResult.java         # Record: metadata + 3 markdown outputs
│       │   └── AgentProgress.java          # Record: SSE event payload
│       │
│       ├── agents/
│       │   ├── LogAnalyzerAgent.java       # LangChain4j AI Service interface
│       │   ├── IssueInvestigatorAgent.java # LangChain4j AI Service interface
│       │   └── SolutionSpecialistAgent.java# LangChain4j AI Service interface
│       │
│       ├── tools/
│       │   └── LogReaderTool.java          # @Tool — reads log files from disk
│       │
│       └── exception/
│           ├── FileValidationException.java
│           ├── AnalysisNotFoundException.java
│           └── GlobalExceptionHandler.java # @RestControllerAdvice
│
├── frontend/                               # React 19 + Vite + TypeScript
│   ├── .gitignore
│   ├── package.json
│   ├── vite.config.ts                      # Dev proxy: /api → localhost:8080
│   ├── tailwind.config.js
│   ├── tsconfig.json
│   ├── index.html
│   ├── Dockerfile
│   ├── nginx.conf                          # Production SPA + API proxy
│   └── src/
│       ├── main.tsx                        # React entry point
│       ├── App.tsx                         # Main app shell
│       ├── index.css                       # Tailwind directives
│       ├── types/
│       │   └── index.ts                    # TypeScript interfaces
│       ├── services/
│       │   └── api.ts                      # Upload, SSE, fetch results
│       ├── hooks/
│       │   └── useAnalysis.ts              # State machine (idle→upload→stream→done)
│       └── components/
│           ├── HeroSection.tsx             # Landing hero
│           ├── FileUpload.tsx              # Drag-and-drop + validation
│           ├── ProgressTracker.tsx          # Real-time agent status (SSE)
│           ├── ResultsTabs.tsx             # 3-tab markdown viewer
│           └── HistorySidebar.tsx          # Past analyses list
│
└── assets/
    └── screenshots/                        # Add your screenshots here

---

Prerequisites

• Java 21 — Download Eclipse Temurin
• Node.js 20+ — Download Node.js
• Azure OpenAI — An active Azure subscription with an OpenAI resource deployed

---

Local Setup

1. Clone the Repository

git clone https://github.com/<your-username>/AADE.git
cd AADE

2. Configure Azure OpenAI Credentials

Edit backend/.env with your actual Azure OpenAI credentials:

AZURE_OPENAI_KEY=your-actual-api-key
AZURE_OPENAI_ENDPOINT=https://your-resource.openai.azure.com/
AZURE_OPENAI_DEPLOYMENT=your-deployment-name

Note: The .env file is gitignored and will not be committed.

3. Start the Backend

cd backend

# Windows
.\mvnw.cmd spring-boot:run

# macOS / Linux
./mvnw spring-boot:run

The backend starts on http://localhost:8080.

You should see:

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
  ...
Started AadeApplication in X.XXX seconds

4. Start the Frontend

Open a new terminal:

cd frontend
npm install
npm run dev

The frontend starts on http://localhost:5173.
The Vite dev server automatically proxies /api requests to the backend on port 8080.

5. Use the Application

1. Open http://localhost:5173 in your browser
2. Drag and drop a .log or .txt file (or use the sample files in dummy_logs/)
3. Watch the three AI agents work in real-time with live progress updates
4. View the results across three tabs: Log Analysis, Investigation Report, Solution Plan

---

API Endpoints

Method	Endpoint	Description
POST	/api/analyze	Upload a log file (multipart form, max 1MB). Returns { chatId }
GET	/api/analyze/{chatId}/stream	SSE stream — real-time agent progress events
GET	/api/analyze/{chatId}/results	Fetch completed analysis results (3 markdown reports)
GET	/api/analyses	List all past analyses (sorted by newest first)

---

Sample Log Files

Two sample log files are included in dummy_logs/ for testing:

• kubernetes_deployment_error.log — ImagePullBackOff failure during a Kubernetes deployment
• database_connection_error.log — PostgreSQL authentication failure with retry exhaustion

---

License

MIT