Skip to content

Latest commit

 

History

History
582 lines (446 loc) · 22.9 KB

File metadata and controls

582 lines (446 loc) · 22.9 KB

AGEIS

Automated Governance & Enterprise Intelligence System

License: MIT Version Build Status
Python TypeScript FastAPI
Next.js PostgreSQL
Redis Docker
AI-Gemini RAG

Enterprise-grade autonomous compliance monitoring, violation detection, and intelligent remediation system

Key FeaturesArchitectureTech StackGetting StartedAPI DocumentationContributing


Table of Contents

  1. Overview
  2. Key Features
  3. System Architecture
  4. Tech Stack
  5. Project Structure
  6. Getting Started
  7. API Documentation
  8. Security
  9. Roadmap
  10. Contributing
  11. License
  12. Acknowledgments

Overview

AGEIS (Automated Governance & Enterprise Intelligence System) is a comprehensive enterprise compliance and governance platform designed to automate regulatory monitoring, detect violations, and provide intelligent remediation through advanced AI agents.

Built with modern cloud-native technologies, AGEIS provides real-time compliance monitoring across multiple regulatory frameworks including PCI-DSS, GDPR, DPDP, and custom organizational policies.

What We Do

AGEIS transforms traditional compliance management by:

  • 🔍 Continuous Monitoring - Real-time scanning of data sources for compliance violations
  • 🤖 AI-Powered Detection - Intelligent pattern recognition using advanced ML models
  • Automated Remediation - Autonomous fixing of detected issues without human intervention
  • 📊 Unified Dashboard - Centralized visibility into compliance posture across the enterprise
  • 📝 Evidence Collection - Automated generation of compliance evidence and audit trails
  • 🔐 Audit Readiness - Always-on audit trail with cryptographic signing

Key Features

Core Features

Feature Description
Multi-Framework Compliance Support for PCI-DSS, GDPR, DPDP, SOC 2, ISO 27001, and custom frameworks
Real-Time Violation Detection Continuous monitoring with instant alerting on policy breaches
AI-Powered Risk Assessment ML-based scoring and prioritization of compliance risks
Automated Evidence Collection Smart generation of compliance documentation and proofs
RAG-Enhanced Queries AI-powered Q&A system trained on regulatory documents
WebSocket Real-Time Updates Live streaming of compliance events and dashboard updates
Role-Based Access Control Granular permissions with JWT-based authentication
API-First Design RESTful APIs for seamless integration with existing systems

Additional Features

  • Regulatory Intelligence - Automated tracking of regulatory changes
  • Compliance Scoring - Dynamic scoring based on control effectiveness
  • Integration Hub - Connectors for AWS, Google Cloud, Azure, GitHub, GitLab, Slack
  • Export Capabilities - PDF/CSV export of reports, evidence packages, and audit logs
  • Explainable AI - Transparent AI decision-making with full audit trails
  • Watcher Agents - Configurable data source monitors with pattern-based triggers

🎯 Spotlight Feature: AI-Powered Autonomous Compliance Agents

AGEIS implements a multi-agent architecture where specialized AI agents work collaboratively to maintain enterprise compliance:

graph TB
    subgraph "AGEIS AI Agents"
        W["Watcher Agent"] -->|"Monitors Data"| DB["Database"]
        W -->|"Triggers Events"| EB["Event Bus"]
        EB -->|"Processes Events"| I["Interpreter Agent"]
        I -->|"Analyzes Context"| M["Monitor Agent"]
        M -->|"Detects Violations"| R["Remediator Agent"]
        R -->|"Takes Action"| DB
        R -->|"Logs Actions"| AL["Audit Ledger"]
    end
    
    subgraph "External Systems"
        API["API Gateway"] --> W
        UI["Frontend UI"] --> API
    end
Loading

Agent Capabilities

Agent Responsibility Key Functions
Watcher Agent Data Source Monitoring Polls databases, APIs, file systems; triggers events on changes
Interpreter Agent Context Analysis Understands regulatory context, maps violations to frameworks
Monitor Agent Pattern Detection Analyzes data streams for compliance violations using ML
Remediator Agent Automated Fixes Executes remediation actions, generates evidence, logs to audit

How It Works

  1. Watch - The Watcher Agent continuously monitors configured data sources
  2. Interpret - The Interpreter Agent analyzes changes in regulatory context
  3. Monitor - The Monitor Agent applies ML-based detection patterns
  4. Remediate - The Remediator Agent automatically fixes violations and generates evidence

System Architecture

High-Level Architecture Diagram

System Architecture

Figure 1: AGEIS High-Level System Architecture showing the interaction between frontend, backend, AI agents, and external integrations.

Component Architecture

flowchart TB
    subgraph "Client Layer"
        FE["Next.js Frontend<br/>Port 3001"]
        Mobile["Mobile Clients"]
    end
    
    subgraph "API Gateway Layer"
        CORS["CORS Middleware"]
        Auth["JWT Authentication"]
        Rate["Rate Limiting"]
    end
    
    subgraph "Application Layer"
        API["FastAPI Backend<br/>Port 8000"]
        
        subgraph "AI Agents"
            Watcher["Watcher Agent"]
            Interpreter["Interpreter Agent"]
            Monitor["Monitor Agent"]
            Remediator["Remediator Agent"]
        end
        
        subgraph "Services"
            RAG["RAG Service"]
            Gemini["Gemini AI Service"]
            Compliance["Compliance Scoring"]
            Evidence["Evidence Generator"]
        end
        
        subgraph "Detection Engine"
            Patterns["Pattern Matching"]
            Validators["Data Validators"]
            Confidence["Confidence Scoring"]
        end
    end
    
    subgraph "Data Layer"
        PG["PostgreSQL<br/>Port 5432"]
        RedisC["Redis<br/>Port 6379"]
        Vector["Vector Store<br/>(RAG Index)"]
    end
    
    subgraph "Event Layer"
        EB["Async Event Bus"]
    end
    
    FE --> CORS
    CORS --> Auth
    Auth --> Rate
    Rate --> API
    
    API --> Watcher
    API --> Interpreter
    API --> Monitor
    API --> Remediator
    
    Watcher --> EB
    EB --> Interpreter
    Interpreter --> Monitor
    Monitor --> Remediator
    
    API --> RAG
    API --> Gemini
    API --> Compliance
    API --> Evidence
    
    API --> Patterns
    API --> Validators
    API --> Confidence
    
    Patterns --> PG
    Validators --> PG
    Confidence --> RedisC
    RAG --> Vector
    
    Remediator --> PG
    Evidence --> PG
Loading

Tech Stack

Technology Overview

Tech Stack

Figure 2: AGEIS Technology Stack showing the complete tooling and frameworks used.

Backend Technologies

Technology Version Purpose
Python 3.11+ Core runtime
FastAPI 0.109+ Web framework
SQLAlchemy 2.0+ ORM
Pydantic 2.0+ Data validation
Python-Jose 3.9+ JWT handling
AsyncPG 0.29+ PostgreSQL async driver
Redis 7.x Caching and pub/sub
Google Gemini Latest AI/LLM integration
LangChain 0.3+ RAG implementation

Frontend Technologies

Technology Version Purpose
Next.js 16.x React framework
React 19.x UI library
TypeScript 5.x Type safety
Tailwind CSS 4.x Styling
Radix UI 1.1.x Component primitives
Recharts 2.15+ Charts
Framer Motion 12.x Animations
Zod 3.25+ Schema validation

Infrastructure and DevOps

Technology Purpose
Docker Containerization
Docker Compose Orchestration
PostgreSQL Primary database
Redis Cache and events

Project Structure

AGEIS/
├── backend/                      # FastAPI Backend
│   ├── main.py                   # Application entry point
│   ├── requirements.txt         # Python dependencies
│   └── app/
│       ├── config.py             # Configuration management
│       ├── database.py           # Database connection and models
│       ├── deps.py               # Dependency injection
│       ├── agents/               # AI Agents
│       │   ├── interpreter.py    # Context interpretation
│       │   ├── monitor.py        # Pattern detection
│       │   ├── remediator.py     # Automated fixes
│       │   └── watcher.py         # Data source monitoring
│       ├── api/                  # API Routes
│       │   ├── auth.py           # Authentication
│       │   ├── compliance.py     # Compliance management
│       │   ├── dashboard_routes.py
│       │   ├── violations.py     # Violation tracking
│       │   ├── watcher_routes.py  # Watcher configuration
│       │   ├── ask_routes.py      # RAG Q and A
│       │   ├── audit.py          # Audit logs
│       │   ├── evidence.py       # Evidence generation
│       │   ├── regulations.py    # Regulation management
│       │   ├── integration.py    # External integrations
│       │   ├── websocket.py      # Real-time updates
│       │   └── health.py         # Health checks
│       ├── detection/            # Detection Engine
│       │   ├── patterns.py       # Pattern definitions
│       │   ├── validators.py     # Data validation
│       │   └── confidence.py     # Confidence scoring
│       ├── events/               # Event Bus
│       ├── models/               # SQLAlchemy Models
│       ├── rag/                  # RAG Implementation
│       │   ├── chain.py          # LangChain chain
│       │   ├── indexer.py        # Vector indexing
│       │   └── retriever.py      # Retrieval logic
│       ├── schemas/              # Pydantic Schemas
│       └── services/             # Business Services
│           ├── auth_service.py
│           ├── compliance_scoring.py
│           ├── evidence_generator.py
│           ├── gemini_service.py
│           └── redis_service.py
│
├── Frontend/                     # Next.js Frontend
│   ├── app/
│   │   ├── dashboard/            # Dashboard page
│   │   ├── compliance/           # Compliance management
│   │   ├── violations/           # Violation tracking
│   │   ├── watcher/              # Watcher configuration
│   │   ├── ask/                  # RAG Q and A interface
│   │   ├── explainability/       # AI explainability
│   │   └── export/               # Export utilities
│   ├── components/
│   │   ├── ui/                   # Reusable UI components
│   │   ├── landing/              # Landing page components
│   │   └── layout-shell.tsx      # Layout wrapper
│   ├── hooks/                    # Custom React hooks
│   ├── lib/                      # Utilities
│   ├── mockdata/                 # Mock data for development
│   └── public/                   # Static assets
│
├── docker/                       # Docker configurations
│   ├── Dockerfile.backend
│   ├── Dockerfile.frontend
│   └── Dockerfile.gateway
│
├── docker-compose.yml            # Docker Compose orchestration
├── .env.example                  # Environment variables template
└── README.md                     # This file

Getting Started

Prerequisites

Ensure you have the following installed:

Requirement Minimum Version
Docker 24.0+
Docker Compose 3.8+
Python 3.11+
Node.js 20.x (for local dev)
pnpm 9.x

Installation

1. Clone the Repository

git clone https://github.com/ageis-project/ageis.git
cd ageis

2. Configure Environment Variables

Copy the example environment file and configure:

cp .env.example backend/.env

Edit backend/.env with your settings:

# Required: Gemini API Key for AI features
GEMINI_API_KEY=your_gemini_api_key_here

# Application Settings
APP_NAME=AGEIS
DEBUG=false
HOST=0.0.0.0
PORT=8000

# Database (PostgreSQL)
DATABASE_URL=postgresql+asyncpg://postgres:postgres@postgres:5432/ageis

# Redis
REDIS_URL=redis://redis:6379

# JWT Secret (generate a secure key for production)
SECRET_KEY=your-super-secret-key-change-in-production

3. Build and Start Services

Using Docker Compose:

# Build and start all services
docker-compose up --build

# Start in detached mode
docker-compose up -d

Running the Application

After starting, access the services at:

Service URL Description
Frontend http://localhost:3001 Next.js web application
Backend API http://localhost:8000 FastAPI REST API
API Docs http://localhost:8000/docs Swagger/OpenAPI documentation
API Redoc http://localhost:8000/redoc ReDoc API documentation

Local Development (Without Docker)

Backend:

cd backend
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
pip install -r requirements.txt
python -m uvicorn main:app --reload --port 8000

Frontend:

cd Frontend
pnpm install
pnpm dev

API Documentation

AGEIS provides comprehensive REST APIs with automatic documentation.

API Endpoints Overview

Category Endpoints
Authentication /api/auth/login, /api/auth/register, /api/auth/refresh
Dashboard /api/compliance, /api/system_liveness, /api/compliance_trend
Compliance /api/compliance/controls, /api/compliance/frameworks
Violations /api/violations, /api/violations/{id}, /api/violations/{id}/remediate
Watchers /api/watchers, /api/watchers/{id}/trigger
Regulations /api/regulations, /api/regulations/{id}
Evidence /api/evidence, /api/evidence/generate
Audit /api/audit/logs, /api/audit/export
Ask AI /api/ask, /api/ask/chat
Integrations /api/integrations, /api/integrations/{provider}

Interactive API Docs

Visit the following URLs when the backend is running:


Security

Security Features

  • JWT Authentication - Token-based authentication with refresh tokens
  • Role-Based Access Control (RBAC) - Granular permissions
  • Password Hashing - Secure password storage with bcrypt
  • CORS Protection - Configurable cross-origin resource sharing
  • Rate Limiting - API rate limiting to prevent abuse
  • Input Validation - Pydantic schema validation
  • SQL Injection Protection - Parameterized queries via SQLAlchemy
  • Audit Logging - All actions logged with timestamps

Security Best Practices

  1. Change the default SECRET_KEY in production
  2. Use HTTPS in production environments
  3. Configure proper CORS origins for your domains
  4. Implement regular security audits
  5. Keep dependencies updated

Roadmap

Upcoming Features

  • Multi-Tenancy Support - Isolated environments for multiple organizations
  • Advanced ML Models - Custom-trained models for specific industries
  • Blockchain Audit Trail - Immutable audit logging
  • Mobile Applications - iOS and Android apps
  • More Integration Connectors - ServiceNow, Jira, Splunk, etc.
  • Custom Policy Engine - No-code policy definition
  • Compliance Forecasting - Predictive compliance analytics
  • Auto-Scaling - Kubernetes deployment manifests

Contributing

We welcome contributions! Please see our Contributing Guide for details.

Development Workflow

  1. Fork the repository
  2. Create a feature branch (git checkout -b feature/amazing-feature)
  3. Commit your changes (git commit -m 'Add amazing feature')
  4. Push to the branch (git push origin feature/amazing-feature)
  5. Open a Pull Request

Code Style

  • Python: Follow PEP 8, use Black formatter
  • TypeScript: Follow ESLint rules, use Prettier
  • Commits: Use Conventional Commits format

License

This project is licensed under the MIT License - see the LICENSE file for details.

MIT License

Copyright (c) 2025 AGEIS (Automated Governance & Enterprise Intelligence System)

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

Acknowledgments


Built with ❤️ by Team CodeFirstThinkLater

GitHub Stars GitHub Forks