Oracle AI Platform

Plateforme Intelligente de Gestion Oracle avec IA

Une plateforme web intégrée combinant l'optimisation des requêtes Oracle, l'audit de sécurité, la détection d'anomalies et la gestion intelligente des sauvegardes/restaurations, assistée par un LLM via Prompt Engineering et RAG.

• Vue d'Ensemble
• Fonctionnalités
• Architecture
• Installation
• Configuration
• Vérification
• Utilisation
• API Reference
• Modules
• Tests
• Structure du Projet
• Contribution
• Licence

Oracle AI Platform est une solution complète d'assistance aux administrateurs de bases de données Oracle, intégrant des capacités d'intelligence artificielle pour automatiser et optimiser les tâches de gestion courantes.

La plateforme utilise des techniques de Retrieval-Augmented Generation (RAG) pour enrichir les réponses d'un Large Language Model (LLM) avec une base de connaissances Oracle spécialisée, permettant de fournir des recommandations précises et contextualisées.

• Backend: Python 3.9+, Flask 3.1
• Frontend: HTML5, CSS3, Bootstrap 5, JavaScript
• LLM: GroqCloud, OpenRouter, Ollama (local)
• Vector Database: ChromaDB
• Embeddings: SentenceTransformers (all-MiniLM-L6-v2)

Évaluation automatisée des risques de sécurité d'une instance Oracle avec génération de rapports détaillés incluant un score de sécurité (0-100), identification des risques par sévérité, et recommandations priorisées.

Fonctionnalités principales:

• Analyse des utilisateurs et rôles
• Vérification des privilèges excessifs
• Évaluation des profils de mot de passe
• Génération de rapports JSON structurés

Analyse des requêtes lentes avec explication des plans d'exécution, identification des goulots d'étranglement, et propositions d'optimisations concrètes (index, hints, réécriture).

Types d'optimisations proposées:

• Création d'index
• Réécriture de requêtes
• Utilisation de hints Oracle
• Mise à jour des statistiques

Classification automatique des logs d'audit Oracle en trois catégories (normal, suspect, critique) avec justification IA et génération d'alertes.

Types d'anomalies détectées:

• Connexions en dehors des heures de bureau
• Escalades de privilèges anormales
• Tentatives d'injection SQL
• Modifications DDL sur objets critiques
• Accès à des données sensibles

Génération de stratégies de sauvegarde optimales basées sur les besoins métier (RPO/RTO) avec création automatique de scripts RMAN.

Paramètres pris en compte:

• Recovery Point Objective (RPO)
• Recovery Time Objective (RTO)
• Budget et ressources disponibles
• Criticité des données

Guide interactif pour les scénarios de récupération Oracle avec génération de playbooks détaillés incluant les commandes RMAN exactes.

Scénarios supportés:

• Restauration complète après crash
• Point-in-Time Recovery (PITR)
• Récupération de table spécifique
• Récupération de lignes via Flashback

Chatbot intelligent avec contexte RAG pour répondre aux questions techniques sur Oracle Database, générer des scripts SQL/PL/SQL, et fournir des recommandations.

Fonctionnalités:

• Réponses contextualisées avec base de connaissances RAG
• Génération de scripts SQL/PL/SQL/RMAN
• Bouton de copie pour les blocs de code
• Persistance de l'historique (localStorage)
• Export de conversation en Markdown
• Support multi-providers LLM

Interface web moderne avec vue d'ensemble des métriques, alertes critiques, et accès rapide à toutes les fonctionnalités.

Pages disponibles:

• Dashboard principal avec métriques
• Page d'audit de sécurité
• Page d'analyse de performance
• Page de détection d'anomalies
• Page de gestion des sauvegardes
• Page d'export/import

Sauvegarde et restauration des données de l'application en multiples formats (JSON, CSV, Markdown, TXT).

Formats supportés:

• JSON: Format structuré complet
• CSV: Compatible tableurs
• Markdown: Documentation lisible
• TXT: Format texte simple

┌─────────────────────────────────────────────────────────┐
│              Interface Web (Flask + Bootstrap)          │
│         Dashboard + Chatbot Conversationnel             │
└────────────────────────┬────────────────────────────────┘
                         │
         ┌───────────────┼───────────────┐
         │               │               │
    ┌────▼────┐    ┌─────▼─────┐   ┌─────▼─────┐
    │ Modules │    │    LLM    │   │  ChromaDB │
    │  (1-10) │    │   Engine  │   │    RAG    │
    └────┬────┘    └───────────┘   └───────────┘
         │
         │ LLM Providers:
         │ • GroqCloud (Gratuit, Rapide)
         │ • OpenRouter (GPT-4)
         │ • Ollama (Local, Privé)
         │
    ┌────▼──────────────────────────────────────┐
    │         Oracle Database Instance          │
    │  V$ Views | Logs d'audit | Plans SQL      │
    └───────────────────────────────────────────┘

Couche Présentation

• Templates Jinja2 + HTML5
• Bootstrap 5 avec design Oracle
• JavaScript pour interactions
• WebSocket pour chat temps réel

Couche API

• REST API endpoints
• Flask-SocketIO pour WebSocket
• Gestion de session Flask

Couche Métier

• 10 modules fonctionnels
• Pattern Singleton pour instances
• Intégration LLM centralisée

Couche Core

• LLM Engine multi-providers
• RAG Setup avec ChromaDB
• 15 documents Oracle indexés

• Python 3.9 ou supérieur
• pip (gestionnaire de paquets Python)
• Ollama (optionnel, pour LLM local gratuit)
• Clé API GroqCloud ou OpenRouter (optionnel)

# 1. Cloner le projet
git clone <repository-url>
cd oracle-ai-platform

# 2. Créer environnement virtuel
python -m venv venv
source venv/bin/activate  # Linux/Mac
# ou: venv\Scripts\activate  # Windows

# 3. Installer dépendances
pip install -r requirements.txt

# 4. Configurer l'environnement
cp env.example .env
# Éditer .env avec vos clés API (voir section Configuration)

# 5. Initialiser la base de connaissances RAG
python src/core/rag_setup.py

# 6. Lancer l'application
python src/app.py

L'application sera accessible sur http://localhost:5000

Créez un fichier .env à la racine du projet avec les variables suivantes:

# LLM Provider (groq, openai, ollama)
LLM_PROVIDER=groq

# GroqCloud (Recommandé - Gratuit et Rapide)
GROQ_API_KEY=votre_cle_groq
GROQ_MODEL=llama-3.3-70b-versatile

# OpenRouter (Alternative)
OPENAI_API_KEY=votre_cle_openrouter
OPENAI_BASE_URL=https://openrouter.ai/api/v1
OPENAI_MODEL=openai/gpt-4o

# Ollama Local (Gratuit, Illimité)
OLLAMA_BASE_URL=http://localhost:11434
OLLAMA_MODEL=qwen2.5-coder:3b

# Oracle Database (optionnel)
ORACLE_HOST=localhost
ORACLE_PORT=1521
ORACLE_SERVICE=ORCL
ORACLE_USER=system
ORACLE_PASSWORD=password

# Application
CHROMA_DB_PATH=data/chroma_db
DATA_DIR=data

Une fois installé, vous pouvez vérifier le bon fonctionnement de tous les modules (Audit, Optimisation, Anomalies, Backup) en exécutant le script de vérification :

python tests/verify_full_flow.py

Ce script simule un flux utilisateur complet et vérifie que :

1. La connexion LLM est active.
2. L'audit de sécurité génère un rapport.
3. L'optimiseur analyse une requête SQL.
4. Le détecteur d'anomalies scanne les logs.
5. Le générateur de backup produit une stratégie.

# Méthode 1: Script principal
python src/app.py

# Méthode 2: Via run_app.py
python run_app.py

# Méthode 3: Flask CLI
export FLASK_APP=src/app.py
flask run --host=0.0.0.0 --port=5000

Le chatbot est accessible via la sidebar sur toutes les pages ou en page dédiée (/chat). Exemples de questions:

• "Pourquoi ma requête SELECT est lente ?"
• "Y a-t-il des risques de sécurité ?"
• "Comment récupérer ma base au 15 mars 14h ?"
• "Quelle stratégie de backup recommandez-vous ?"
• "Écris un script PL/SQL pour surveiller les sessions actives"

# Lancer un audit
POST /api/security/audit

# Récupérer le rapport
GET /api/security/report

# Analyser une requête SQL
POST /api/query/analyze
Content-Type: application/json
{
    "sql_query": "SELECT * FROM employees WHERE dept_id = 10"
}

# Détecter les anomalies
POST /api/anomalies/detect
Content-Type: application/json
{
    "limit": 10
}

# Générer une stratégie
POST /api/backup/generate
Content-Type: application/json
{
    "rpo": "4 heures",
    "rto": "1 heure",
    "budget": "élevé"
}

# Générer un script RMAN
POST /api/backup/rman-script
Content-Type: application/json
{
    "strategy": {...}
}

# Générer un playbook de récupération
POST /api/recovery/playbook
Content-Type: application/json
{
    "query": "Comment récupérer ma base au 15 mars 14h ?"
}

# Chatbot conversationnel
POST /api/chat
Content-Type: application/json
{
    "query": "Qu'est-ce qu'un index Oracle ?"
}

# Exporter un module
GET /api/export/{module}?format=json|csv|markdown
# Modules: security, performance, anomalies, chatbot, backups

# Exporter tout
GET /api/export/all

# Importer des données
POST /api/import/{module}
Content-Type: multipart/form-data
file: <fichier.json>

# Importer des logs
POST /api/import/logs
Content-Type: multipart/form-data
file: <logs.json|logs.csv>

# Récupérer le provider actuel
GET /api/llm/provider

# Changer de provider
POST /api/llm/provider
Content-Type: application/json
{
    "provider": "groq|openai|ollama"
}

src/modules/data_extractor.py

• Connexion Oracle (cx_Oracle/oracledb)
• Extraction logs d'audit, plans, configs
• Mode mock pour tests sans Oracle

src/core/rag_setup.py

• ChromaDB local
• 15 documents Oracle indexés
• Fonction retrieve_context()

src/core/llm_engine.py

• Interface unifiée 3 providers
• Prompts centralisés (data/prompts.yaml)
• Gestion erreurs et retry

src/modules/security_audit.py

• Score sécurité 0-100
• Risques par sévérité
• Recommandations

src/modules/query_optimizer.py

• Analyse plans d'exécution
• Détection bottlenecks
• Suggestions d'optimisation

src/modules/anomaly_detector.py

• Classification logs (normal/suspect/critique)
• Détection SQL injection
• Génération d'alertes

src/modules/backup_recommender.py

• Stratégies basées RPO/RTO
• Scripts RMAN générés
• Estimation coûts

src/modules/recovery_guide.py

• 4 scénarios de récupération
• Playbooks détaillés
• Chatbot conversationnel

src/app.py

• Flask + Bootstrap 5
• Design Oracle
• WebSocket chat

src/modules/export_manager.py

• Export JSON/CSV/Markdown
• Import avec validation
• Historique fichiers

# Tests unitaires
pytest tests/ -v

# Avec couverture
pytest tests/ -v --cov=src --cov-report=html

# Test rapide d'un module
pytest tests/test_security_audit.py -v
pytest tests/test_query_optimizer.py -v
pytest tests/test_anomaly_detector.py -v

166 tests unitaires - Taux de réussite: 100%

# Tester la configuration LLM
python -c "from src.core.llm_engine import LLMEngine; e = LLMEngine(); print(f'Provider: {e.provider}')"

# Tester l'import d'un module
python -c "from src.modules.export_manager import ExportManager; print('OK')"

oracle-ai-platform/
├── src/
│   ├── core/
│   │   ├── llm_engine.py      # Module 3: LLM Engine
│   │   └── rag_setup.py       # Module 2: RAG Setup
│   ├── modules/
│   │   ├── data_extractor.py  # Module 1: Extraction
│   │   ├── security_audit.py  # Module 4: Sécurité
│   │   ├── query_optimizer.py # Module 5: Performance
│   │   ├── anomaly_detector.py# Module 6: Anomalies
│   │   ├── backup_recommender.py # Module 7: Backups
│   │   ├── recovery_guide.py  # Module 8: Restauration
│   │   └── export_manager.py  # Module 10: Export/Import
│   ├── utils/
│   │   └── config.py          # Configuration centralisée
│   └── app.py                 # Module 9: Application Flask
├── data/
│   ├── prompts.yaml           # Prompts LLM centralisés
│   ├── knowledge_base/         # Documents Oracle pour RAG
│   ├── chroma_db/             # Base vectorielle
│   └── synthetic_logs.json    # Logs de test
├── templates/                  # Templates HTML Flask
├── static/
│   ├── css/                   # Styles CSS
│   ├── js/                    # JavaScript
│   └── images/                # Logos et icônes
├── tests/                     # Tests unitaires
├── requirements.txt           # Dépendances Python
├── run_app.py                 # Script de lancement
└── README.md                  # Ce fichier

# Vérifier l'environnement virtuel
source venv/bin/activate
pip install -r requirements.txt

# Si erreur 402 avec OpenRouter:
1. Vérifiez vos crédits sur https://openrouter.ai/settings/credits
2. Vérifiez que la clé dans .env correspond bien au bon compte
3. Alternative: Utilisez Groq (Gratuit) en changeant LLM_PROVIDER=groq

# Changer le port dans src/app.py
# ou tuer le processus existant
lsof -i :5000
kill -9 <PID>

1. Vérifier la configuration LLM dans .env
2. Vérifier que RAG est initialisé: python src/core/rag_setup.py
3. Vérifier les logs dans le terminal

Les contributions sont les bienvenues. Pour contribuer:

1. Fork le projet
2. Créer une branche pour votre fonctionnalité (git checkout -b feature/AmazingFeature)
3. Commit vos changements (git commit -m 'Add some AmazingFeature')
4. Push vers la branche (git push origin feature/AmazingFeature)
5. Ouvrir une Pull Request

Ce projet est développé dans le cadre académique - Administration Oracle 2025.

• EL GORRIM Mohamed
• KCHIBAL Ismail

Développé dans le cadre du cours d'Administration Oracle - Faculté des Sciences et Techniques de Tanger, Université Abdelmalek Essaâdi.

• Ne jamais commiter les clés API
• Utiliser .env pour les configurations sensibles
• Les données synthétiques sont fournies pour les tests
• Surveiller les coûts API si utilisation de services payants