Initial deployment: Scrap-Dji with API

.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,44 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+venv/
+env/
+ENV/
+
+# Environnement
+.env
+.env.local
+config.env
+
+# Données et logs
+data/
+logs/
+*.log
+storage_data/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Hugging Face Spaces
+flagged/
+
+# Bases de données locales (si utilisées)
+*.db
+*.sqlite
+*.sqlite3
+
+# Fichiers temporaires
+*.tmp
+*.temp
+.cache/

DEPLOYMENT_GUIDE.md

@@ -0,0 +1,270 @@
+# Guide de Déploiement sur Hugging Face Spaces
+
+## 📋 Prérequis
+
+1. **Compte Hugging Face** : [Créer un compte](https://huggingface.co/join)
+2. **Git installé** sur votre machine
+3. **Projet Scrap-Dji** prêt avec les fichiers suivants :
+   - ✅ `app.py` (créé)
+   - ✅ `requirements.txt` (optimisé)
+   - ✅ `README.md` (avec metadata HF)
+   - ✅ `.gitignore` (configuré)
+   - ✅ `sources.json` (avec sources Togo + Bénin)
+
+---
+
+## 🚀 Étapes de Déploiement
+
+### 1. Créer un Space sur Hugging Face
+
+1. Allez sur [huggingface.co/new-space](https://huggingface.co/new-space)
+2. Remplissez les informations :
+   - **Owner** : Votre username
+   - **Space name** : `scrap-dji` (ou autre nom)
+   - **License** : MIT
+   - **Select the Space SDK** : **Gradio**
+   - **Visibility** : **Private** ✅ (comme demandé)
+3. Cliquez sur **Create Space**
+
+### 2. Cloner le Space localement
+
+```bash
+# Cloner le Space vide
+git clone https://huggingface.co/spaces/VOTRE_USERNAME/scrap-dji
+cd scrap-dji
+```
+
+### 3. Copier les fichiers du projet
+
+```bash
+# Depuis le répertoire Scrap-Dji
+# Copier tous les fichiers nécessaires vers le Space
+
+# Fichiers principaux
+cp app.py /path/to/scrap-dji/
+cp requirements.txt /path/to/scrap-dji/
+cp README.md /path/to/scrap-dji/
+cp .gitignore /path/to/scrap-dji/
+cp sources.json /path/to/scrap-dji/
+
+# Copier les dossiers du code
+cp -r scraper/ /path/to/scrap-dji/
+cp -r parser/ /path/to/scrap-dji/
+cp -r utils/ /path/to/scrap-dji/
+cp -r indexer/ /path/to/scrap-dji/
+
+# Créer le dossier data (sera persistant sur HF)
+mkdir -p /path/to/scrap-dji/data
+```
+
+### 4. Pousser vers Hugging Face
+
+```bash
+cd /path/to/scrap-dji
+
+# Ajouter tous les fichiers
+git add .
+
+# Commit
+git commit -m "Initial deployment: Scrap-Dji with API endpoints"
+
+# Pousser vers HF
+git push
+```
+
+### 5. Vérifier le Build
+
+1. Allez sur votre Space : `https://huggingface.co/spaces/VOTRE_USERNAME/scrap-dji`
+2. Cliquez sur l'onglet **Logs** pour voir le build en cours
+3. Attendez que le status passe à **Running** ✅
+
+---
+
+## 🔧 Configuration Post-Déploiement
+
+### Vérifier que tout fonctionne
+
+1. **Interface Gradio** : `https://VOTRE_USERNAME-scrap-dji.hf.space/`
+2. **API Docs** : `https://VOTRE_USERNAME-scrap-dji.hf.space/docs`
+3. **Health Check** : `https://VOTRE_USERNAME-scrap-dji.hf.space/api/health`
+
+### Test de l'API depuis votre frontend
+
+```javascript
+// Exemple de requête depuis votre frontend
+const API_URL = 'https://VOTRE_USERNAME-scrap-dji.hf.space';
+
+// Recherche
+const searchResults = await fetch(`${API_URL}/api/search`, {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({
+    query: 'économie togo',
+    pays: 'Togo',
+    limit: 20,
+    fuzzy: true
+  })
+});
+
+const data = await searchResults.json();
+console.log(data.results);
+
+// Statistiques
+const stats = await fetch(`${API_URL}/api/stats`);
+const statsData = await stats.json();
+console.log(statsData);
+```
+
+---
+
+## 📊 Endpoints API Disponibles
+
+| Endpoint | Méthode | Description |
+|----------|---------|-------------|
+| `/api/search` | POST/GET | Recherche avec filtres |
+| `/api/stats` | GET | Statistiques de la base |
+| `/api/documents` | GET | Liste paginée des documents |
+| `/api/documents/{id}` | GET | Document par ID |
+| `/api/reload` | POST | Recharger les documents |
+| `/api/health` | GET | Health check |
+| `/docs` | GET | Documentation Swagger |
+
+---
+
+## 🎯 Optimisations Recommandées
+
+### 1. Pré-scraper des données avant déploiement
+
+Pour éviter de démarrer avec une base vide :
+
+```bash
+# Sur votre machine locale
+python scrape_togo_massive.py
+
+# Copier le fichier de données généré
+cp data/search_index.json /path/to/scrap-dji/data/documents.json
+
+# Commit et push
+cd /path/to/scrap-dji
+git add data/documents.json
+git commit -m "Add pre-scraped data"
+git push
+```
+
+### 2. Limiter le scraping initial sur HF
+
+Pour éviter les timeouts, modifiez temporairement `sources.json` :
+
+```json
+{
+  "settings": {
+    "max_pages_per_source": 50,  // Au lieu de 500
+    "concurrent_requests": 5      // Au lieu de 10
+  }
+}
+```
+
+### 3. Activer le cache pour les recherches
+
+Le cache est déjà implémenté dans `app.py` pour optimiser les performances.
+
+---
+
+## 🐛 Dépannage
+
+### Problème : Build échoue
+
+**Solution** : Vérifiez les logs dans l'onglet "Logs" du Space. Souvent causé par :
+- Dépendances manquantes dans `requirements.txt`
+- Erreurs de syntaxe Python
+- Imports manquants
+
+### Problème : "Module not found"
+
+**Solution** : Vérifiez que tous les dossiers sont bien copiés :
+```bash
+ls -la /path/to/scrap-dji/
+# Doit contenir: scraper/, parser/, utils/, indexer/
+```
+
+### Problème : API retourne []
+
+**Solution** : La base est vide. Lancez le scraping depuis l'interface Gradio ou pré-scrapez des données.
+
+### Problème : Timeout lors du scraping
+
+**Solution** : Réduisez le nombre de sources actives dans `sources.json` ou limitez `max_pages_per_source`.
+
+---
+
+## 🔒 Sécurité (Space Privé)
+
+Votre Space est **privé**, donc :
+- ✅ Seul vous pouvez y accéder
+- ✅ L'API nécessite une authentification HF
+- ⚠️ Pour partager avec votre frontend, vous devrez :
+  1. Rendre le Space public, OU
+  2. Utiliser un token HF dans votre frontend
+
+### Option : Utiliser un token HF
+
+```javascript
+// Dans votre frontend
+const response = await fetch(`${API_URL}/api/search`, {
+  method: 'POST',
+  headers: {
+    'Content-Type': 'application/json',
+    'Authorization': 'Bearer YOUR_HF_TOKEN'
+  },
+  body: JSON.stringify({ query: 'test' })
+});
+```
+
+---
+
+## 📈 Monitoring
+
+### Voir les logs en temps réel
+
+```bash
+# Depuis votre terminal local
+huggingface-cli repo logs spaces/VOTRE_USERNAME/scrap-dji
+```
+
+### Statistiques d'utilisation
+
+Consultez l'onglet **Analytics** de votre Space pour voir :
+- Nombre de requêtes
+- Temps de réponse
+- Erreurs
+
+---
+
+## 🔄 Mise à Jour du Space
+
+Pour mettre à jour le code après modification :
+
+```bash
+cd /path/to/scrap-dji
+
+# Modifier vos fichiers
+# ...
+
+# Commit et push
+git add .
+git commit -m "Update: description des changements"
+git push
+```
+
+Le Space se rebuild automatiquement ! ✨
+
+---
+
+## 📞 Support
+
+- **Documentation HF Spaces** : [docs.huggingface.co/hub/spaces](https://huggingface.co/docs/hub/spaces)
+- **Forum HF** : [discuss.huggingface.co](https://discuss.huggingface.co)
+
+---
+
+**Votre projet est maintenant prêt pour Hugging Face ! 🎉**

FAQ.md

@@ -0,0 +1,265 @@
+# FAQ - Scrap-Dji : Questions et Réponses
+
+## 📊 Que puis-je faire avec les données scrapées ?
+
+### Fonctionnalités principales :
+1. **Recherche sémantique** : Trouver du contenu par similarité de sens
+2. **Recherche par mots-clés** : Recherche classique par termes
+3. **Filtrage géographique** : Contenus par pays/région africaine
+4. **Analyse temporelle** : Évolution des sujets dans le temps
+5. **Détection de langues** : Contenus en français, anglais, langues locales
+6. **Analyse de sentiments** : Positif/négatif/neutre
+7. **Extraction d'entités** : Personnes, organisations, lieux
+8. **Génération de résumés** : Synthèse automatique des articles
+9. **Détection de fake news** : Analyse de crédibilité
+10. **API REST** : Interface pour applications tierces
+
+### Exemples d'utilisation :
+- **Journaliste** : Recherche d'articles sur un sujet spécifique
+- **Chercheur** : Analyse de tendances médiatiques africaines
+- **Développeur** : API pour application mobile/web
+- **Analyste** : Rapports sur l'actualité africaine
+
+## 📋 Quelles données sont récupérées ?
+
+### Données extraites :
+```json
+{
+  "titre": "Titre de l'article",
+  "texte": "Contenu complet nettoyé",
+  "source_url": "URL d'origine",
+  "pays": "Sénégal",
+  "langue": "fr",
+  "type_document": "article|social|pdf|video",
+  "auteur": "Nom de l'auteur",
+  "date_publication": "2024-01-15",
+  "tags": ["politique", "économie"],
+  "images": ["url1", "url2"],
+  "liens_externes": ["url1", "url2"],
+  "métadonnées": {
+    "longueur_texte": 1500,
+    "nombre_mots": 250,
+    "sentiment": "positif",
+    "crédibilité": 0.85
+  }
+}
+```
+
+### Types de sources supportées :
+- **Sites d'actualités** : Articles, éditoriaux, interviews
+- **Réseaux sociaux** : Twitter, Facebook (via API)
+- **Blogs** : Contenus personnels et professionnels
+- **PDFs** : Documents officiels, rapports
+- **Vidéos** : YouTube, Vimeo (métadonnées)
+- **Podcasts** : Transcriptions et descriptions
+
+## 🔄 Reprise du scraping après interruption
+
+### ✅ Oui, le système évite les doublons !
+
+**Mécanisme de détection :**
+1. **Hash du contenu** : Chaque document a un hash unique
+2. **URL de source** : Vérification par URL d'origine
+3. **Timestamp** : Horodatage pour versioning
+4. **Base de données** : Vérification en PostgreSQL/MongoDB
+
+**Comportement :**
+```python
+# Si document existe déjà
+if existing_document:
+    # Création d'une nouvelle version
+    new_version = DocumentVersion(
+        document_id=existing.id,
+        texte=new_content,
+        date=datetime.now()
+    )
+    # Pas de doublon, juste mise à jour
+else:
+    # Nouveau document
+    create_new_document()
+```
+
+**Avantages :**
+- ✅ Pas de répétition des données
+- ✅ Mise à jour des contenus modifiés
+- ✅ Historique des versions
+- ✅ Reprise automatique où ça s'est arrêté
+
+## 🗄️ Configuration des bases de données
+
+### PostgreSQL (Obligatoire)
+```bash
+# 1. Télécharger depuis https://www.postgresql.org/download/windows/
+# 2. Installer avec les paramètres par défaut
+# 3. Créer la base de données
+createdb scrapdji
+
+# 4. Configurer dans .env
+POSTGRES_URI=postgresql://postgres:votre_mot_de_passe@localhost:5432/scrapdji
+```
+
+### MongoDB (Obligatoire)
+```bash
+# 1. Télécharger depuis https://www.mongodb.com/try/download/community
+# 2. Installer MongoDB Community Server
+# 3. Démarrer le service
+net start MongoDB
+
+# 4. Configurer dans .env
+MONGO_URI=mongodb://localhost:27017
+MONGO_DB=scrapdji
+```
+
+### Typesense (Optionnel - Recherche avancée)
+```bash
+# Installation via Docker (recommandé)
+docker run -p 8108:8108 -v typesense-data:/data typesense/typesense:latest --data-dir /data --api-key=xyz
+
+# Ou télécharger l'exécutable Windows
+# https://github.com/typesense/typesense/releases
+```
+
+### Qdrant (Optionnel - IA/ML)
+```bash
+# Installation via Docker
+docker run -p 6333:6333 qdrant/qdrant
+
+# Ou télécharger l'exécutable
+# https://github.com/qdrant/qdrant/releases
+```
+
+## 💾 Consommation des ressources
+
+### Estimation des ressources :
+
+**Scraping léger (10 sources) :**
+- CPU : 5-10% (processeur moderne)
+- RAM : 200-500 MB
+- Disque : 1-5 GB/jour
+- Réseau : 10-50 MB/source
+
+**Scraping intensif (100+ sources) :**
+- CPU : 20-40%
+- RAM : 1-2 GB
+- Disque : 10-50 GB/jour
+- Réseau : 100-500 MB/source
+
+### Optimisations :
+```python
+# Configuration optimisée dans .env
+SCRAPER_DELAY=2                    # Délai entre requêtes
+SCRAPER_CONCURRENT_REQUESTS=8      # Requêtes simultanées
+SCRAPER_TIMEOUT=30                 # Timeout des requêtes
+SCRAPER_RETRY_TIMES=3              # Nombre de tentatives
+```
+
+### Recommandations :
+- **Débutant** : 5-10 sources, scraping toutes les heures
+- **Intermédiaire** : 20-50 sources, scraping toutes les 30 minutes
+- **Avancé** : 100+ sources, scraping en continu avec queue
+
+## 🔧 Configuration Git
+
+### Fichier .gitignore
+```gitignore
+# Environnement virtuel
+venv/
+env/
+.venv/
+
+# Variables d'environnement
+.env
+.env.local
+.env.production
+
+# Logs
+logs/
+*.log
+
+# Données scrapées
+storage_data/
+data/
+temp/
+
+# Cache
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Base de données
+*.db
+*.sqlite
+
+# Fichiers temporaires
+*.tmp
+*.temp
+```
+
+### Commandes Git recommandées :
+```bash
+# Initialiser le repository
+git init
+
+# Ajouter les fichiers de configuration
+git add .gitignore
+git add config.env.example
+git add sources.json.example
+
+# Premier commit
+git commit -m "Initial commit - Configuration Scrap-Dji"
+
+# Ajouter le code source
+git add .
+git commit -m "Ajout du code source Scrap-Dji"
+
+# Créer une branche pour le développement
+git checkout -b develop
+```
+
+## 🚀 Script de configuration automatique
+
+```bash
+# Script pour configurer tout automatiquement
+python setup.py --auto
+
+# Ou configuration manuelle
+python setup.py --interactive
+```
+
+## 📊 Monitoring et métriques
+
+### Métriques disponibles :
+- **Documents traités** : Nombre total
+- **Nouvelles sources** : Sources découvertes
+- **Taux de succès** : Pourcentage de succès
+- **Temps de traitement** : Durée par source
+- **Erreurs** : Logs d'erreurs détaillés
+
+### Dashboard (futur) :
+- Interface web pour visualiser les métriques
+- Graphiques en temps réel
+- Alertes automatiques
+- Export des données
+
+## 🎯 Prochaines étapes recommandées
+
+1. **Installation** : PostgreSQL + MongoDB
+2. **Configuration** : .env et sources.json
+3. **Test** : Lancement avec --dry-run
+4. **Déploiement** : Scraping en production
+5. **Optimisation** : Ajustement des paramètres
+6. **Monitoring** : Surveillance des performances
+7. **API** : Déploiement de l'API FastAPI
+8. **Frontend** : Interface utilisateur web 

INCONSISTENCY_REPORT.md

@@ -0,0 +1,40 @@
+# Rapport de Détection des Incohérences - Scrap-Dji
+
+Après une analyse approfondie de l'ensemble des fichiers et de la logique du projet, voici les incohérences majeures détectées, classées par catégorie.
+
+## 1. Pipeline de Données Brisé (Grave)
+Le plus gros problème est que les composants sont définis mais ne communiquent pas entre eux :
+- **Scraper vers Indexeur** : Le script `scraper/main.py` sauvegarde les données uniquement dans **PostgreSQL**. Il n'appelle jamais les indexeurs `indexer/typesense_indexer.py` ou `indexer/qdrant_indexer.py`. Résultat : les données scrapées ne sont jamais indexées pour la recherche.
+- **Scraper vers Storage** : Le `StorageManager` (gestion des fichiers locaux) est initialisé dans le scraper mais n'est jamais utilisé pour télécharger ou stocker des images/PDF, bien que le modèle `db/models.py` prévoie une table `Image`.
+- **Scraper vers NoSQL** : Le projet prévoit d'utiliser MongoDB pour la flexibilité, mais le scraper n'envoie aucune donnée vers le `mongo_connector.py`.
+
+## 2. Redondance de Code (Maintenabilité)
+Il existe trois classes presque identiques pour la même tâche (découverte de sources) :
+1. `UniversalSource` (`scraper/universal_source.py`)
+2. `SourceDiscovery` (`scraper/discovery.py`)
+3. `AutoSourceDiscovery` (`scraper/auto_discovery.py`)
+Ces trois fichiers partagent ~80% de leur logique (détection de langue, détection de pays par extension de domaine, filtrage par mots-clés). Cela crée un risque de divergence de logique.
+
+## 3. Incohérences de Dépendances (`requirements.txt`)
+Plusieurs dépendances sont déclarées mais non utilisées, ou utilisées mais non déclarées :
+- **Manquants** : `python-whois` est importé dans `discovery.py` mais absent de `requirements.txt`.
+- **Inutiles** : `scrapy` est listé dans le README et les dépendances, mais **aucun** fichier dans `/scraper` ne l'utilise (tout est fait avec `requests` + `BeautifulSoup`).
+- **Inutiles** : `meilisearch` est listé mais aucun code n'existe pour l'utiliser (seuls Typesense et Qdrant ont des connecteurs).
+
+## 4. Incohérences Logiques et Bugs Potentiels
+- **Filtres de Pays** : `auto_discovery.py` (ligne 181) rejette toutes les sources dont le pays est "Afrique", alors que `UniversalSource` et `SourceDiscovery` les acceptent.
+- **Sélecteurs Hardcodés** : Dans `auto_discovery.py` (ligne 132), les sélecteurs CSS sont injectés en dur, ignorant totalement ceux qui pourraient être plus précis dans `sources.json`.
+- **API Fantôme** : `api/main.py` est une simple coquille. Elle ne contient aucune logique de recherche réelle. Elle renvoie simplement les filtres passés en paramètre sans interroger la base de données.
+- **Logs Inconsistants** : `utils/config.py` définit un chemin de log via variable d'environnement, mais `utils/logger.py` le force en dur dans `Path("logs") / "scrapdji.log"`.
+
+## 5. Architecture vs. Réalité (README)
+- **Vision vs Code** : Le README promet un "Scraping multi-sources avec Scrapy". En réalité, le code utilise une approche séquentielle simple avec `requests` qui sera beaucoup plus lente et moins robuste pour le passage à l'échelle.
+- **Typesense/Meilisearch** : Le README mentionne les deux comme interchangeables, mais le code ne supporte que Typesense.
+
+---
+
+## 💡 Recommandations Prioritaires
+1. **Centraliser la découverte** : Fusionner les 3 fichiers de découverte en un seul module robuste.
+2. **Connecter les fils** : Modifier `scraper/main.py` pour qu'il appelle systématiquement `indexer.index_document()` après avoir sauvegardé en base de données.
+3. **Nettoyer le `requirements.txt`** : Aligner les dépendances sur le code réel.
+4. **Implémenter l'API** : Connecter FastAPI à PostgreSQL (pour les métadonnées) et Typesense (pour la recherche plein texte).

INSTALL_WINDOWS.md

@@ -0,0 +1,255 @@
+# Guide d'installation Windows - Scrap-Dji
+
+## 🪟 Installation des services sur Windows
+
+### 1. PostgreSQL
+
+#### Téléchargement et installation :
+1. Aller sur https://www.postgresql.org/download/windows/
+2. Télécharger PostgreSQL 15+ pour Windows
+3. Exécuter l'installateur
+4. **Important** : Noter le mot de passe de l'utilisateur `postgres`
+5. Laisser le port par défaut (5432)
+
+#### Configuration :
+```bash
+# Ouvrir Command Prompt en tant qu'administrateur
+# Créer la base de données
+psql -U postgres -c "CREATE DATABASE scrapdji;"
+
+# Tester la connexion
+psql -U postgres -d scrapdji -c "SELECT version();"
+```
+
+#### Configuration dans .env :
+```env
+POSTGRES_URI=postgresql://postgres:votre_mot_de_passe@localhost:5432/scrapdji
+```
+
+### 2. MongoDB
+
+#### Téléchargement et installation :
+1. Aller sur https://www.mongodb.com/try/download/community
+2. Télécharger MongoDB Community Server pour Windows
+3. Exécuter l'installateur
+4. Choisir "Complete" installation
+5. Installer MongoDB Compass (interface graphique)
+
+#### Démarrer le service :
+```bash
+# Démarrer MongoDB
+net start MongoDB
+
+# Vérifier le statut
+sc query MongoDB
+```
+
+#### Configuration dans .env :
+```env
+MONGO_URI=mongodb://localhost:27017
+MONGO_DB=scrapdji
+```
+
+### 3. Typesense (Optionnel)
+
+#### Option A : Docker (Recommandé)
+```bash
+# Installer Docker Desktop depuis https://www.docker.com/products/docker-desktop/
+# Puis lancer :
+docker run -p 8108:8108 -v typesense-data:/data typesense/typesense:latest --data-dir /data --api-key=xyz
+```
+
+#### Option B : Exécutable Windows
+1. Aller sur https://github.com/typesense/typesense/releases
+2. Télécharger `typesense-server-0.25.0-windows-amd64.exe`
+3. Créer un dossier `C:\typesense`
+4. Copier l'exécutable et créer un fichier `config.json` :
+```json
+{
+  "api-key": "xyz",
+  "data-dir": "C:\\typesense\\data",
+  "enable-cors": true
+}
+```
+
+#### Démarrer Typesense :
+```bash
+# Créer un service Windows
+sc create Typesense binPath= "C:\typesense\typesense-server.exe --config=C:\typesense\config.json"
+sc start Typesense
+```
+
+### 4. Qdrant (Optionnel)
+
+#### Option A : Docker
+```bash
+docker run -p 6333:6333 qdrant/qdrant
+```
+
+#### Option B : Exécutable Windows
+1. Aller sur https://github.com/qdrant/qdrant/releases
+2. Télécharger `qdrant-1.7.4-x86_64-pc-windows-msvc.zip`
+3. Extraire dans `C:\qdrant`
+4. Créer un service :
+```bash
+sc create Qdrant binPath= "C:\qdrant\qdrant.exe"
+sc start Qdrant
+```
+
+## 🔧 Configuration automatique
+
+### Script de configuration Windows :
+```powershell
+# Exécuter en tant qu'administrateur
+Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+
+# Lancer la configuration
+python setup.py --windows
+```
+
+### Vérification des services :
+```powershell
+# Vérifier PostgreSQL
+Get-Service -Name "postgresql*"
+
+# Vérifier MongoDB
+Get-Service -Name "MongoDB"
+
+# Vérifier les ports
+netstat -an | findstr ":5432"
+netstat -an | findstr ":27017"
+netstat -an | findstr ":8108"
+netstat -an | findstr ":6333"
+```
+
+## 🚀 Lancement du scraping
+
+### 1. Préparation :
+```bash
+# Activer l'environnement virtuel
+venv\Scripts\activate
+
+# Installer les dépendances
+pip install -r requirements.txt
+```
+
+### 2. Configuration :
+```bash
+# Copier les fichiers de configuration
+copy config.env.example .env
+copy sources.json.example sources.json
+
+# Éditer .env avec vos paramètres
+notepad .env
+```
+
+### 3. Test :
+```bash
+# Test sans sauvegarde
+python run_scraper.py --dry-run
+
+# Lancement complet
+python run_scraper.py
+```
+
+## 🐛 Dépannage Windows
+
+### Erreur PostgreSQL :
+```bash
+# Vérifier le service
+sc query postgresql-x64-15
+
+# Redémarrer si nécessaire
+sc stop postgresql-x64-15
+sc start postgresql-x64-15
+
+# Vérifier la connexion
+psql -U postgres -c "SELECT 1;"
+```
+
+### Erreur MongoDB :
+```bash
+# Vérifier le service
+sc query MongoDB
+
+# Redémarrer si nécessaire
+net stop MongoDB
+net start MongoDB
+
+# Vérifier la connexion
+mongosh --eval "db.runCommand('ping')"
+```
+
+### Erreur de permissions :
+```powershell
+# Donner les permissions à l'utilisateur
+icacls "C:\Program Files\PostgreSQL" /grant "Users":(OI)(CI)F
+icacls "C:\ProgramData\MongoDB" /grant "Users":(OI)(CI)F
+```
+
+### Erreur de port déjà utilisé :
+```bash
+# Voir qui utilise le port
+netstat -ano | findstr :5432
+
+# Tuer le processus si nécessaire
+taskkill /PID <PID> /F
+```
+
+## 📊 Monitoring Windows
+
+### Services à surveiller :
+```powershell
+# Script de monitoring
+Get-Service -Name "postgresql*", "MongoDB" | Select-Object Name, Status, StartType
+```
+
+### Logs Windows :
+```powershell
+# Voir les logs d'événements
+Get-EventLog -LogName Application -Source "PostgreSQL*" -Newest 10
+Get-EventLog -LogName Application -Source "MongoDB*" -Newest 10
+```
+
+### Performance :
+```powershell
+# Surveiller les ressources
+Get-Counter "\Processor(_Total)\% Processor Time"
+Get-Counter "\Memory\Available MBytes"
+```
+
+## 🔒 Sécurité Windows
+
+### Firewall :
+```powershell
+# Autoriser PostgreSQL
+netsh advfirewall firewall add rule name="PostgreSQL" dir=in action=allow protocol=TCP localport=5432
+
+# Autoriser MongoDB
+netsh advfirewall firewall add rule name="MongoDB" dir=in action=allow protocol=TCP localport=27017
+```
+
+### Antivirus :
+- Ajouter les dossiers du projet aux exclusions
+- Autoriser Python et les services dans l'antivirus
+
+## 📋 Checklist d'installation
+
+- [ ] PostgreSQL installé et configuré
+- [ ] MongoDB installé et démarré
+- [ ] Typesense installé (optionnel)
+- [ ] Qdrant installé (optionnel)
+- [ ] Environnement virtuel créé
+- [ ] Dépendances installées
+- [ ] Fichier .env configuré
+- [ ] Fichier sources.json configuré
+- [ ] Test --dry-run réussi
+- [ ] Premier scraping lancé
+
+## 🎯 Prochaines étapes
+
+1. **Configurer vos sources** dans `sources.json`
+2. **Optimiser les paramètres** selon vos besoins
+3. **Automatiser le scraping** avec Task Scheduler
+4. **Monitorer les performances** avec les outils Windows
+5. **Sauvegarder régulièrement** les bases de données 

OPTIMIZATION_STRATEGIES.md

@@ -0,0 +1,80 @@
+# Stratégie d'Optimisation : "Performance Max, Coût Mini"
+
+Vous avez raison : le passage au "Big Data" multimédia (OCR, Vidéo) explose les coûts si on reste sur une approche naïve. Voici comment diviser la facture par 10 grâce à l'ingénierie logicielle.
+
+---
+
+## 🏗️ 1. Architecture "Tiered Storage" (Le Stockage Intelligent)
+
+Le secret n'est pas de tout garder en RAM, mais de hiérarchiser la donnée.
+
+*   **Hot Data (RAM / NVMe)** : Les vecteurs de recherche et métadonnées récentes (3 derniers mois).
+*   **Warm Data (SSD Standard)** : Les textes intégraux.
+*   **Cold Data (Object Storage S3/MinIO)** : Les fichiers originaux (PDF, Images, Vidéos) et les archives vieilles.
+
+> **L'Astuce :** Qdrant permet de garder les vecteurs sur disque (Mmap) et seulement l'index de navigation (HNSW) en RAM.
+> **Gain** : On passe de 128 Go RAM nécessaire à **16-32 Go RAM** pour le même volume de données.
+
+---
+
+## 📉 2. La Quantisation (Compression Vectorielle)
+
+C'est la révolution récente (2023-2024) dans les bases vectorielles. Au lieu de stocker des nombres à virgule flottante (Float32 -> 4 octets), on les compresse.
+
+*   **Binary Quantization** : Transforme les vecteurs en 0 et 1.
+    *   **Réduction** : **32x moins de RAM**.
+    *   **Perte de précision** : Minime (< 5%) pour la recherche sémantique.
+    *   **Vitesse** : Recherche 40x plus rapide.
+*   **Scalar Quantization (Int8)** :
+    *   **Réduction** : **4x moins de RAM**.
+
+> **Impact Coût :** Vous pouvez faire tourner un index de 10-20 Millions de documents sur un simple serveur standard (32 Go RAM) au lieu d'un monstre.
+
+---
+
+## 🖼️ 3. Pipeline Multimédia "Paresseux" (Lazy Processing)
+
+Ne traitez pas tout, tout de suite. L'OCR et l'analyse vidéo coûtent cher en CPU/GPU.
+
+### Stratégie "On-Demand" & "Tri"
+1.  **Ingestion Rapide** : Téléchargez et stockez le fichier brut (Image/Vidéo) sur S3 (frais minimes).
+2.  **Filtrage Intelligent** : N'envoyez à l'OCR/Vision AI que les fichiers pertinents (ex: images contenant du texte détecté par un algo léger, ou vidéos avec des mots-clés dans le titre/description).
+3.  **Traitement Vidéo** :
+    *   Ne traitez pas la vidéo -> Extrayez 1 frame toutes les 5 secondes.
+    *   N'écoutez pas tout -> Transcrivez (Whisper Small) uniquement l'audio.
+
+---
+
+## 🤖 4. Modèles "Small is Beautiful"
+
+Pour l'Afrique, les modèles géants (Llama-3-70B) sont souvent overkill et lents.
+
+*   **Modèles d'Embedding** : Utilisez des modèles "distillés" (ex: `paraphrase-multilingual-MiniLM-L12-v2`). Ils sont minuscules, rapides et très performants pour la recherche multilingue.
+*   **OCR** : `PaddleOCR` (léger et rapide) vs Tesseract (vieux et lent) ou API Google (chère).
+
+---
+
+## ⚡ 5. L'Infrastructure Optimisée (Exemple Concret)
+
+Voici comment on tient la charge avec un budget divisé par 5 :
+
+### Nouvelle Config "Optimisée"
+*   **Serveur Principal** (Api + Vector DB): VPS 8 vCPU / 32 Go RAM.
+    *   *Techno* : Qdrant (Binary Quantization + Mmap storage).
+*   **Serveur Workers (Scraping/OCR)** : Instances "Spot" (jetables, -60% du prix).
+    *   On en lance 10 quand on en a besoin, on les tue après.
+*   **Stockage Froid** : MinIO (Self-hosted) ou S3 (Wasabi = 6$/To).
+
+**Résultat :**
+*   **Coût Mensuel** : ~100-150$ / mois (au lieu de 600$+).
+*   **Capacité** : ~50 Millions de documents.
+*   **Multimédia** : Traitement asynchrone la nuit ou sur demande.
+
+---
+
+## 🎯 Conclusion
+
+L'argument "Imbattable" évolue : 
+> **"Une intelligence souveraine frugal et agile, capable de tourner sur des infrastructures locales standards."**
+
+C'est encore plus pertinent pour l'Afrique : on ne dépend pas non plus des datacenters géants.

PROJECT_ANALYSIS.md

@@ -0,0 +1,91 @@
+# Analyse Détaillée du Projet Scrap-Dji
+
+## 1. Vue d'ensemble de l'Architecture
+
+Le projet **Scrap-Dji** est une plateforme modulaire conçue pour la collecte, le traitement et l'indexation de contenus panafricains. L'architecture suit une approche pipeline classique :
+
+1.  **Collecte (`/scraper`)** : Utilise divers outils (Scrapy, Newspaper3k, Snscrape, Selenium) pour extraire des données brutes de sites web, réseaux sociaux et documents.
+2.  **Traitement (`/parser`)** : Nettoyage HTML, dédoublonnage par hashage, et structuration des données.
+3.  **Stockage (`/db` & `/storage`)** : Hybride entre relationnel (PostgreSQL pour la structure) et NoSQL (MongoDB pour la flexibilité).
+4.  **Indexation (`/indexer`)** : Double indexation pour la recherche textuelle (Typesense/Meilisearch) et sémantique (Qdrant).
+5.  **Exposition (`/api` & `/frontend`)** : API FastAPI et une interface de recherche minimaliste.
+
+---
+
+## 2. Réponses à vos Questions Spécifiques
+
+### 🧠 Que peut-on faire concrètement avec les données ?
+Une fois les données scrapées, les possibilités sont vastes :
+- **Moteur de recherche souverain** : Créer un portail de recherche spécialisé sur les thématiques africaines.
+- **Analyse de tendances (OSINT)** : Suivre les sujets brûlants sur les réseaux sociaux et dans la presse de différents pays africains.
+- **Entraînement d'IA** : Utiliser les textes pour fine-tuner des modèles de langage (LLM) sur des contextes ou langues africaines.
+- **Veille médiatique** : Automatiser la surveillance de sources spécifiques pour des rapports quotidiens.
+
+### 📊 Quelles sont les données récupérées ?
+D'après les modèles (`db/models.py`), le projet capture :
+- **Identifiants** : UUID unique pour chaque document.
+- **Contenu** : Titre, texte intégral, langue, tags.
+- **Métadonnées** : Auteur, pays d'origine, date de publication, type de document (article, social, PDF, image).
+- **Source** : URL d'origine (essentiel pour la traçabilité).
+- **Relations** : Liens vers des versions antérieures du texte (historisation) et chemins vers les images téléchargées.
+
+### 🔄 Reprise du scraping et doublons
+**Oui, le script gère la reprise sans répétition.**
+Dans `scraper/main.py` (ligne 108), la méthode `save_document` vérifie si l'URL existe déjà en base (`source_url`). 
+- Si l'URL existe : il crée une nouvelle **version** du texte (`DocumentVersion`) mais ne recrée pas le document principal.
+- Pour **Mongo, Typesense et Qdrant**, le code utilise des opérations `upsert` (mise à jour si existe, sinon insertion), ce qui garantit l'absence de doublons identiques.
+
+### 💻 Configuration sans installation locale (Windows)
+Comme vous n'avez pas Mongo/Typesense/Qdrant installé, voici les alternatives :
+1.  **Docker (Recommandé)** : C'est le plus simple. Installez Docker Desktop et utilisez un fichier `docker-compose.yml` pour lancer tous les services en une commande.
+2.  **Cloud (Gratuit/Freemium)** : 
+    - **MongoDB** : Utilisez [MongoDB Atlas](https://www.mongodb.com/cloud/atlas).
+    - **Typesense** : [Typesense Cloud](https://cloud.typesense.org/).
+    - **Qdrant** : [Qdrant Cloud](https://qdrant.tech/cloud/).
+3.  **Désactivation temporaire** : Vous pouvez modifier `scraper/main.py` pour commenter les appels aux indexeurs que vous ne possédez pas encore.
+
+### ⚡ Ressources et Performance
+Le scraper sera-t-il gourmand ?
+- **CPU/RAM** : Le scraping de base est léger. Par contre, si vous utilisez **Selenium** pour des sites dynamiques ou **SpaCy** pour l'enrichissement NLP, la consommation grimpera significativement.
+- **Réseau** : Dépend de `SCRAPER_CONCURRENT_REQUESTS` (actuellement 16). 16 requêtes simultanées est raisonnable pour une connexion standard.
+- **Stockage** : Prévoyez de l'espace si vous téléchargez beaucoup d'images.
+
+---
+
+## 3. Configuration Git recommandée
+
+Pour éviter de commiter vos secrets et votre environnement, assurez-vous que votre `.gitignore` contient :
+
+```gitignore
+# Environnement virtuel
+venv/
+.venv/
+env/
+
+# Secrets et config
+.env
+sources.json
+
+# Données locales
+storage_data/
+logs/
+data/
+temp/
+datasets/
+db/*.sqlite
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+```
+
+---
+
+## 4. Analyse de l'état actuel (Détails)
+
+- **Force** : Architecture très propre et modulaire. Le choix d'une double base (Postgres/Mongo) et d'un double moteur de recherche est très pro.
+- **Points à améliorer** :
+    - L'API (`api/main.py`) est encore vide (ne fait pas de vraie recherche).
+    - Le frontend est ultra-basique (uniquement JSON brut).
+    - Le mode `dry-run` (test sans sauvegarde) n'est pas encore implémenté.

QUICKSTART.md

@@ -0,0 +1,138 @@
+# Guide de démarrage rapide - Scrap-Dji
+
+## 🚀 Démarrage en 5 minutes
+
+### 1. Installation rapide
+```bash
+# Activer l'environnement virtuel
+venv\Scripts\activate  # Windows
+# ou
+source venv/bin/activate  # Linux/Mac
+
+# Installer les dépendances
+pip install -r requirements.txt
+```
+
+### 2. Configuration automatique
+```bash
+# Lance la configuration automatique
+python setup.py
+```
+
+### 3. Configuration manuelle (si nécessaire)
+```bash
+# Copier les fichiers de configuration
+copy config.env.example .env
+copy sources.json.example sources.json
+
+# Éditer .env avec vos paramètres
+notepad .env
+
+# Éditer sources.json avec vos sources
+notepad sources.json
+```
+
+### 4. Test rapide
+```bash
+# Test sans sauvegarde
+python run_scraper.py --dry-run
+
+# Lancement complet
+python run_scraper.py
+```
+
+## 📋 Configuration minimale
+
+### Fichier .env minimal
+```env
+POSTGRES_URI=postgresql://user:password@localhost:5432/scrapdji
+MONGO_URI=mongodb://localhost:27017
+MONGO_DB=scrapdji
+STORAGE_PATH=./storage_data
+```
+
+### Fichier sources.json minimal
+```json
+{
+  "sources": [
+    {
+      "name": "test_site",
+      "type": "news",
+      "url": "https://example.com",
+      "selectors": {
+        "title": "h1",
+        "content": "p"
+      },
+      "pays": "Test",
+      "langue": "fr",
+      "active": true
+    }
+  ]
+}
+```
+
+## 🔧 Services requis
+
+### PostgreSQL
+```bash
+# Installation Windows
+# Télécharger depuis https://www.postgresql.org/download/windows/
+
+# Créer la base
+createdb scrapdji
+```
+
+### MongoDB
+```bash
+# Installation Windows
+# Télécharger depuis https://www.mongodb.com/try/download/community
+
+# Démarrer le service
+net start MongoDB
+```
+
+## 🐛 Dépannage
+
+### Erreur de connexion PostgreSQL
+- Vérifiez que PostgreSQL est installé et démarré
+- Vérifiez les paramètres de connexion dans .env
+
+### Erreur de connexion MongoDB
+- Vérifiez que MongoDB est installé et démarré
+- Vérifiez l'URI dans .env
+
+### Erreur d'import
+```bash
+# Réinstaller les dépendances
+pip install -r requirements.txt --force-reinstall
+```
+
+### Erreur de scraping
+- Vérifiez que les URLs dans sources.json sont accessibles
+- Vérifiez les sélecteurs CSS
+- Testez avec --dry-run d'abord
+
+## 📊 Monitoring
+
+### Logs
+```bash
+# Consulter les logs
+tail -f logs/scrapdji.log
+```
+
+### Base de données
+```bash
+# Connexion PostgreSQL
+psql -d scrapdji
+
+# Connexion MongoDB
+mongosh scrapdji
+```
+
+## 🎯 Prochaines étapes
+
+1. **Configurer vos sources** : Modifiez `sources.json` avec vos sites cibles
+2. **Optimiser les sélecteurs** : Ajustez les sélecteurs CSS pour chaque site
+3. **Configurer l'indexation** : Activez Typesense/Qdrant pour la recherche
+4. **Déployer l'API** : Lancez l'API FastAPI pour l'interface web
+5. **Automatiser** : Configurez des tâches cron pour le scraping régulier 

QUICK_START.md

@@ -0,0 +1,165 @@
+# 🚀 QUICK START - Scrap-Dji pour Hugging Face
+
+## ✅ Votre projet est PRÊT !
+
+Tous les fichiers nécessaires ont été créés. Voici comment procéder :
+
+---
+
+## 📋 Étape 1 : Test Local (5 minutes)
+
+```bash
+# 1. Installer les dépendances
+pip install -r requirements.txt
+
+# 2. Lancer l'application
+python app.py
+```
+
+✅ Ouvrez `http://localhost:7860` dans votre navigateur  
+✅ Testez la recherche dans l'onglet "🔍 Recherche"  
+✅ Lancez un scraping de test dans l'onglet "🚀 Scraping"
+
+### Test de l'API
+
+Dans un autre terminal :
+```bash
+python test_api.py
+```
+
+Résultat attendu : **6/6 tests réussis** ✅
+
+---
+
+## 🌐 Étape 2 : Test du Frontend (2 minutes)
+
+1. Gardez `python app.py` en cours d'exécution
+2. Ouvrez `frontend_example.html` dans votre navigateur
+3. Testez une recherche
+
+---
+
+## ☁️ Étape 3 : Déploiement sur Hugging Face (10 minutes)
+
+### 3.1 Créer un Space
+
+1. Allez sur https://huggingface.co/new-space
+2. Remplissez :
+   - **Space name** : `scrap-dji`
+   - **SDK** : Gradio
+   - **Visibility** : **Private** ✅
+3. Cliquez sur **Create Space**
+
+### 3.2 Pousser le Code
+
+```bash
+# Cloner le Space vide
+git clone https://huggingface.co/spaces/VOTRE_USERNAME/scrap-dji
+cd scrap-dji
+
+# Copier TOUS les fichiers du projet Scrap-Dji
+# (Remplacez /path/to/Scrap-Dji par le vrai chemin)
+cp -r /path/to/Scrap-Dji/* .
+
+# OU sur Windows PowerShell :
+# Copy-Item -Path "C:\Users\MSI\Desktop\Scrap-Dji\*" -Destination "." -Recurse
+
+# Ajouter et pousser
+git add .
+git commit -m "Initial deployment: Scrap-Dji with API"
+git push
+```
+
+### 3.3 Vérifier le Déploiement
+
+1. Attendez 2-3 minutes (build en cours)
+2. Vérifiez les logs dans l'onglet "Logs" du Space
+3. Une fois "Running" ✅, testez :
+   - Interface : `https://VOTRE_USERNAME-scrap-dji.hf.space/`
+   - API Docs : `https://VOTRE_USERNAME-scrap-dji.hf.space/docs`
+
+---
+
+## 🔌 Étape 4 : Intégrer dans Votre Frontend
+
+Dans votre code frontend, remplacez l'URL :
+
+```javascript
+// Avant (test local)
+const API_URL = 'http://localhost:7860';
+
+// Après (production)
+const API_URL = 'https://VOTRE_USERNAME-scrap-dji.hf.space';
+```
+
+### Exemple de Requête
+
+```javascript
+// Recherche
+const response = await fetch(`${API_URL}/api/search`, {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({
+    query: 'économie togo',
+    pays: 'Togo',
+    limit: 20,
+    fuzzy: true
+  })
+});
+
+const data = await response.json();
+console.log(data.results);
+
+// Statistiques
+const stats = await fetch(`${API_URL}/api/stats`);
+const statsData = await stats.json();
+console.log(statsData);
+```
+
+---
+
+## 📚 Documentation Complète
+
+- **Guide de déploiement** : [DEPLOYMENT_GUIDE.md](DEPLOYMENT_GUIDE.md)
+- **Walkthrough complet** : Voir les artifacts
+- **Exemple frontend** : [frontend_example.html](frontend_example.html)
+
+---
+
+## 🎯 Endpoints API Disponibles
+
+| Endpoint | Méthode | Description |
+|----------|---------|-------------|
+| `/api/search` | POST/GET | Recherche avec filtres |
+| `/api/stats` | GET | Statistiques |
+| `/api/documents` | GET | Liste paginée |
+| `/api/documents/{id}` | GET | Document par ID |
+| `/api/health` | GET | Health check |
+| `/docs` | GET | Documentation Swagger |
+
+---
+
+## ⚡ Fonctionnalités Clés
+
+✅ **Recherche permissive** : Tolère les fautes de frappe  
+✅ **Filtres** : Par pays, langue  
+✅ **Scoring** : Résultats classés par pertinence  
+✅ **12 sources** : 8 Togo + 4 Bénin  
+✅ **API REST** : 7 endpoints pour votre frontend  
+✅ **Interface Gradio** : 4 onglets interactifs  
+
+---
+
+## 🆘 Besoin d'Aide ?
+
+- **Problème de build** : Vérifiez les logs dans l'onglet "Logs" du Space
+- **API ne répond pas** : Vérifiez que le Space est "Running"
+- **Base vide** : Lancez un scraping depuis l'interface Gradio
+
+---
+
+## 🎉 C'est Tout !
+
+Votre projet est **production-ready**. Suivez les étapes ci-dessus et vous serez déployé en 15 minutes ! 🚀
+
+**Bon déploiement !** 🌍

README.md

@@ -1,12 +1,148 @@
 ---
-title: Scrap Dji
-emoji: 👁
-colorFrom: pink
-colorTo: red
+title: Scrap-Dji - Base de Connaissance Panafricaine
+emoji: 🌍
+colorFrom: green
+colorTo: blue
 sdk: gradio
-sdk_version: 6.5.1
+sdk_version: 4.44.0
 app_file: app.py
 pinned: false
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🌍 Scrap-Dji - Base de Connaissance Panafricaine
+
+Système de scraping et de recherche de contenus africains (Togo, Bénin, Afrique).
+
+## 🚀 Fonctionnalités
+
+### 🔍 Recherche Intelligente
+- **Recherche permissive** avec tolérance aux fautes de frappe (fuzzy matching)
+- **Filtres avancés** par pays, langue, date
+- **Scoring de pertinence** pour des résultats optimaux
+- **API REST complète** pour intégration frontend
+
+### 📰 Scraping Multi-Sources
+- Collecte automatique depuis sources togolaises et béninoises
+- Extraction intelligente de contenu (titre, texte, métadonnées)
+- Déduplication automatique
+- Stockage persistant
+
+### 📊 Statistiques
+- Répartition par pays, langue, source
+- Visualisation des données collectées
+- Métriques en temps réel
+
+## 🔌 API Endpoints
+
+### Recherche
+```bash
+# POST avec JSON
+curl -X POST "https://YOUR_SPACE.hf.space/api/search" \
+  -H "Content-Type: application/json" \
+  -d '{"query": "économie togo", "limit": 10, "fuzzy": true}'
+
+# GET simple
+curl "https://YOUR_SPACE.hf.space/api/search?q=politique&pays=Togo&limit=20"
+```
+
+### Statistiques
+```bash
+curl "https://YOUR_SPACE.hf.space/api/stats"
+```
+
+### Documents
+```bash
+# Liste paginée
+curl "https://YOUR_SPACE.hf.space/api/documents?skip=0&limit=10"
+
+# Document par ID
+curl "https://YOUR_SPACE.hf.space/api/documents/{id}"
+```
+
+### Health Check
+```bash
+curl "https://YOUR_SPACE.hf.space/api/health"
+```
+
+## 📖 Documentation Interactive
+
+Une fois déployé, accédez à la documentation Swagger interactive :
+- **Swagger UI** : `https://YOUR_SPACE.hf.space/docs`
+- **ReDoc** : `https://YOUR_SPACE.hf.space/redoc`
+
+## 🛠️ Technologies
+
+- **Backend** : FastAPI + Gradio
+- **Scraping** : newspaper3k, BeautifulSoup, lxml
+- **NLP** : NLTK, langdetect
+- **Recherche** : Moteur local avec fuzzy matching
+
+## 📝 Utilisation
+
+### Interface Web
+Accédez directement à l'interface Gradio pour :
+1. Effectuer des recherches
+2. Lancer le scraping
+3. Consulter les statistiques
+
+### Intégration Frontend
+
+```javascript
+// Exemple de recherche depuis votre frontend
+const response = await fetch('https://YOUR_SPACE.hf.space/api/search', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({
+    query: 'économie togo',
+    pays: 'Togo',
+    limit: 20,
+    fuzzy: true
+  })
+});
+
+const data = await response.json();
+console.log(data.results);
+```
+
+## 🌍 Sources Couvertes
+
+### Togo
+- TogoFirst
+- 27septembre
+- IciLome
+- TogoBreakingNews
+- RepublicOfTogo
+- TogoActualite
+- LomeInfo
+- TogoSite
+
+### Bénin
+- BeninWebTV
+- La Nouvelle République
+- (Plus de sources à venir)
+
+## 📄 License
+
+MIT License - Libre d'utilisation et de modification
+
+## 👨‍💻 Développement
+
+Pour contribuer ou déployer localement :
+
+```bash
+# Cloner le projet
+git clone https://huggingface.co/spaces/YOUR_USERNAME/scrap-dji
+
+# Installer les dépendances
+pip install -r requirements.txt
+
+# Lancer l'application
+python app.py
+```
+
+L'application sera accessible sur `http://localhost:7860`
+
+---
+
+**Développé avec ❤️ pour l'Afrique**

RESOURCE_ESTIMATION.md

@@ -0,0 +1,92 @@
+# Estimation des Ressources : Projet "Dataset Souverain & IA"
+
+Ce document détaille les prérequis techniques pour passer d'un simple scraper à une **usine de données pour l'IA** (LLM Fine-tuning & RAG).
+
+---
+
+## 1. 💾 Stockage : Le Nerf de la Guerre
+
+Pour un dataset "conséquent" (visant le fine-tuning d'un LLM 7B ou 13B paramètres sur des contextes africains), on ne parle plus en gigaoctets mais en téraoctets.
+
+### Estimation pour 10 Millions d'articles/documents (High Quality) :
+*   **Données Brutes (HTML/PDF)** : ~500 Go - 1 To (pour archives et traçabilité).
+*   **Données Nettoyées (Texte brut/JSON)** : ~50 Go - 100 Go (TEXT ONLY).
+*   **Index Vectoriel (RAG)** : C'est le plus lourd.
+    *   Si on découpe (chunk) chaque doc en 4 segments.
+    *   40 millions de vecteurs (768 dimensions float32).
+    *   **Taille RAM/Disque Qdrant/Typesense** : ~150 Go - 200 Go uniquement pour les vecteurs.
+
+**Recommandation Disque :** **2 To NVMe SSD** minimum. Les disques durs classiques (HDD) tueront les performances de votre moteur de recherche vectoriel.
+
+---
+
+## 2. 🖥️ Matériel pour le Scraper (L'Usine)
+
+Le scraping n'est pas limité par le CPU, mais par la **bande passante** et les **IOPS** (écritures disque).
+
+### Configuration "Scraper Industriel" (Minimum)
+*   **CPU** : 4 - 8 vCPUs (pour gérer le parsing HTML/PDF en parallèle).
+*   **RAM** : 16 Go - 32 Go (Chrome/Selenium consomme énormément si utilisé, sinon Scrapy pur est léger).
+*   **Réseau** : 1 Gbps stable.
+*   **Proxies** : **CRITIQUE**. Pour scraper massivement sans être banni, il faut un pool de proxies rotatifs (frais mensuels à prévoir : 50$-500$/mois selon le volume).
+
+---
+
+## 3. ⏱️ Estimation du Temps (La Variable "Politesse")
+
+Si vous êtes "poli" (1 requête/seconde par domaine) pour ne pas casser les sites cibles :
+
+*   **Vitesse Moyenne** : 1 page / 2 secondes (avec parsing).
+*   **Avec 1 instance** : ~43 000 pages / jour.
+*   **Pour atteindre 1 Million de pages** : ~23 jours avec 1 machine.
+*   **Accélération** : Parallélisme. Avec 10 workers en parallèle sur des domaines différents -> **2 à 3 jours pour 1 Million de pages**.
+
+---
+
+## 4. 🧠 Structure des Données pour l'IA (LLM & RAG)
+
+Pour que la donnée soit utile (et pas juste du bruit), elle doit suivre ce pipeline :
+
+### A. Pour le RAG (Recherche Sémantique)
+Les données doivent être "Chunkées" (découpées) intelligemment.
+*   **Format** : JSON
+*   **Structure** :
+    ```json
+    {
+      "id": "uuid",
+      "text": "Extrait de texte de 512 tokens...",
+      "metadata": {
+        "source": "url",
+        "date": "2024-01-01",
+        "pays": "Sénégal",
+        "langue": "wol"
+      },
+      "vector": [0.12, -0.45, ...] // Généré par modèle d'embedding (ex: Camembert, NLLB)
+    }
+    ```
+
+### B. Pour le Fine-Tuning (LLM)
+Les données doivent être nettoyées et formatées en paires "Instruction/Input/Output" ou en texte brut continu de haute qualité.
+*   **Format** : JSONL (JSON Lines)
+*   **Nettoyage** : Suppression des pubs, menus, bas de pages, scripts, etc. (C'est 80% du travail).
+
+---
+
+## 5. ⚡ Performance du Moteur de Recherche
+
+Pour que la recherche soit "instantanée" (< 100ms) sur des millions de documents :
+
+1.  **RAM is King** : Qdrant et Typesense doivent tenir l'index en mémoire vive (RAM).
+    *   Pour 10M vecteurs, prévoyez **64 Go à 128 Go de RAM** sur le serveur de recherche.
+2.  **Disque NVMe** : Indispensable pour charger les données à froid.
+3.  **HNSW Index** : C'est l'algorithme utilisé par Qdrant. Il est rapide mais gourmand en RAM.
+
+---
+
+## 📝 Résumé du "Kit de Démarrage Sérieux"
+
+Si vous voulez commencer demain un projet pertinent et performant :
+
+1.  **Serveur Scraper** : VPS 8 vCPU / 16 Go RAM / 1 Gbps (ex: Hetzner, OVH) + Budget Proxies.
+2.  **Serveur Base de Données & Recherche** : Serveur Dédié 16 vCPU / 128 Go RAM / 2x1.92 To NVMe (C'est là qu'est la valeur).
+3.  **Pipeline** : Scrapy (Collecte) -> Traitement Text (Spacy/Langchain) -> Vectorisation (HuggingFace) -> Qdrant (Index).

TOGO_BENIN_ESTIMATION.md

@@ -0,0 +1,74 @@
+# Estimation Ciblée : Togo 🇹🇬 & Bénin 🇧🇯
+
+Voici une projection réaliste pour "scraper tout le web pertinent" de ces deux pays.
+
+---
+
+## 📊 1. Estimation du Volume (La Cible)
+
+Le web togolais et béninois est moins vaste que le web mondial, mais très dense sur les réseaux sociaux.
+
+*   **Sites d'Actualités & Blogs** : ~150 sources majeures (x 10 ans d'archives) = **~2 Millions d'articles**.
+*   **Documents Officiels (JO, Lois, Rapports)** : **~50 000 PDF**.
+*   **Réseaux Sociaux (Facebook, X, LinkedIn, Commentaires)** : C'est le plus gros morceau. Discussions politiques, sociales, buzz. = **~30 à 50 Millions de posts/commentaires pertinents**.
+
+**TOTAL CIBLE : ~50 Millions d'unités de données.**
+
+---
+
+## 💾 2. Besoins de Stockage (Par usage)
+
+Voici ce qu'il vous faut selon vos trois objectifs :
+
+### A. Base de Données "Brute Structurée" (💰 Pour la Vente)
+*C'est la donnée "Patrimoniale". On garde tout (HTML source, métadonnées, JSON complet).*
+*   **Volume** : 50 Millions de fichiers JSON + Métadonnées.
+*   **Estimation** : **1.5 To à 2 To**.
+*   **Stockage recommandé** : Disque Dur (HDD) ou S3 (Pas cher).
+
+### B. Dataset "Fine-Tuning LLM" (🧠 Pour l'Entraînement)
+*C'est la donnée "Raffinée". Texte pur, nettoyé, format JSONL (Instruction/Response).*
+*   **Volume** : Le nettoyage supprime 90% du bruit (HTML, pubs).
+*   **Estimation** : **~100 Go à 150 Go** de texte pur haute qualité.
+*   **Stockage recommandé** : SSD standard (rapide à lire pour l'entraînement).
+
+### C. Base Vectorielle (🔎 Pour RAG & Recherche Avancée)
+*C'est la donnée "Intelligente". Vecteurs mathématiques.*
+*   **Calcul** : 50M docs x 3 chunks (moyenne) = 150 Millions de vecteurs.
+*   **Estimation (Standard Float32)** : ~450 Go (Trop lourd/cher).
+*   **Estimation (Optimisée/Quantized)** : **~30 Go à 50 Go** (Tient sur un serveur standard !).
+*   **Stockage recommandé** : NVMe + RAM (32Go).
+
+---
+
+## ⏱️ 3. Estimation du Temps de Scraping
+
+Combien de temps pour récupérer ces 50 millions d'items ?
+
+### Scénario 1 : Le "Loup Solitaire" (1 Serveur, Prudent)
+*   *Vitesse* : 1 requête / 2 secondes (pour ne pas se faire bannir).
+*   **Temps estimé** : **~3 ans**. (Inenvisageable).
+
+### Scénario 2 : L'Approche "Commando" (20 Workers en Parallèle)
+*   *Architecture* : 20 processus tournant en même temps sur des cibles différentes (Facebook, TogoWeb, BeninSoir, etc.).
+*   *Vitesse cumulée* : ~10 pages / seconde.
+*   **Temps estimé** : **~60 jours (2 mois)** pour tout l'historique.
+
+### Scénario 3 : L'Approche "Industrielle" (Cloud Scaling)
+*   *Architecture* : 50 à 100 workers lancés massivement sur 1 semaine.
+*   **Temps estimé** : **~7 à 10 jours**.
+*   *Risque* : Fort risque de bannissement (IP blocking). Nécessite un gros budget Proxies.
+
+---
+
+## 💡 Ma Recommandation Stratégique
+
+Pour le Togo et le Bénin, ne visez pas la force brute immédiate.
+1.  **Lancez une flotte "Moyenne" (10-15 workers)** stable.
+2.  Laissez tourner en fond pendant **3 mois**.
+3.  Priorisez les **Archives de Presse** (facile et rapide) le premier mois, puis les **Réseaux Sociaux** (lent et complexe) ensuite.
+
+**Infrastructure requise pour ce plan :**
+*   **Stockage** : 1 Disque 4 To (couvre tout pour ~100€).
+*   **Serveur** : 1 VPS Costaud (8 vCPU / 32 Go RAM) pour la BDD + Scraping.
+*   **Total Matériel** : Investissement minime (~60-80€/mois) pour une valorisation de données énorme.

TROUBLESHOOTING.md

@@ -0,0 +1,230 @@
+# 🔧 Guide de Résolution des Problèmes
+
+## ❌ Problème 1 : Authentification Hugging Face Échouée
+
+### Erreur
+```
+remote: Invalid username or password.
+fatal: Authentication failed for 'https://huggingface.co/spaces/jojonocode/Scrap-Dji/'
+```
+
+### ✅ Solution : Utiliser un Token d'Accès
+
+Hugging Face nécessite un **token d'accès** au lieu d'un mot de passe pour Git.
+
+#### Méthode 1 : Via Hugging Face CLI (RECOMMANDÉ)
+
+```bash
+# 1. Installer Hugging Face CLI
+pip install huggingface_hub
+
+# 2. Se connecter avec votre token
+huggingface-cli login
+# Collez votre token quand demandé : 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
+
+# 3. Cloner le Space
+huggingface-cli repo clone spaces/jojonocode/Scrap-Dji
+```
+
+#### Méthode 2 : Via Git avec Token dans l'URL
+
+```bash
+# Utiliser le token directement dans l'URL
+git clone https://jojonocode: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@huggingface.co/spaces/jojonocode/Scrap-Dji
+```
+
+#### Méthode 3 : Via l'Interface Web (PLUS SIMPLE)
+
+**C'est la méthode la plus simple si Git pose problème !**
+
+1. **Allez sur votre Space** : https://huggingface.co/spaces/jojonocode/Scrap-Dji
+2. **Cliquez sur "Files"** en haut
+3. **Cliquez sur "Add file" → "Upload files"**
+4. **Glissez-déposez** tous vos fichiers depuis `C:\Users\MSI\Desktop\Scrap-Dji\`
+5. **Commit** : Écrivez "Initial deployment" et cliquez sur "Commit"
+
+**Fichiers à uploader** :
+- ✅ `app.py`
+- ✅ `requirements.txt`
+- ✅ `README.md`
+- ✅ `.gitignore`
+- ✅ `sources.json`
+- ✅ Dossiers : `scraper/`, `parser/`, `utils/`, `indexer/`
+
+---
+
+## ❌ Problème 2 : Module 'gradio' Non Trouvé
+
+### Erreur
+```
+ModuleNotFoundError: No module named 'gradio'
+```
+
+### ✅ Solution : Installer les Dépendances
+
+```bash
+# Dans votre environnement virtuel (venv activé)
+pip install -r requirements.txt
+```
+
+**Vérification** :
+```bash
+# Vérifier que gradio est installé
+pip list | findstr gradio
+```
+
+Résultat attendu :
+```
+gradio                4.44.0
+```
+
+---
+
+## 🚀 Déploiement Simplifié (Sans Git)
+
+### Option A : Via l'Interface Web HF (RECOMMANDÉ)
+
+**Étapes** :
+
+1. **Créer le Space** (si pas déjà fait)
+   - Allez sur https://huggingface.co/new-space
+   - Name: `Scrap-Dji`
+   - SDK: Gradio
+   - Visibility: Private
+   - Cliquez "Create Space"
+
+2. **Uploader les fichiers**
+   - Cliquez sur "Files" → "Add file" → "Upload files"
+   - Sélectionnez TOUS les fichiers de votre projet :
+     ```
+     app.py
+     requirements.txt
+     README.md
+     .gitignore
+     sources.json
+     scraper/ (tout le dossier)
+     parser/ (tout le dossier)
+     utils/ (tout le dossier)
+     indexer/ (tout le dossier)
+     ```
+   - Commit avec le message : "Initial deployment"
+
+3. **Attendre le Build**
+   - Allez dans l'onglet "Logs"
+   - Attendez que le status passe à "Running" (2-3 minutes)
+
+4. **Tester**
+   - Ouvrez votre Space : https://huggingface.co/spaces/jojonocode/Scrap-Dji
+   - L'interface Gradio devrait s'afficher !
+
+### Option B : Via Git avec Token
+
+Si vous voulez absolument utiliser Git :
+
+```bash
+# 1. Installer HF CLI
+pip install huggingface_hub
+
+# 2. Login
+huggingface-cli login
+# Token : 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
+
+# 3. Cloner
+huggingface-cli repo clone spaces/jojonocode/Scrap-Dji Scrap-Dji-HF
+cd Scrap-Dji-HF
+
+# 4. Copier les fichiers
+Copy-Item -Path "C:\Users\MSI\Desktop\Scrap-Dji\*" -Destination "." -Recurse -Exclude @("venv", ".git", "data", "logs", "__pycache__")
+
+# 5. Push
+git add .
+git commit -m "Initial deployment"
+git push
+```
+
+---
+
+## 🧪 Test Local (Avant Déploiement)
+
+Une fois les dépendances installées :
+
+```bash
+# 1. Activer venv (si pas déjà fait)
+.\venv\Scripts\Activate.ps1
+
+# 2. Installer les dépendances
+pip install -r requirements.txt
+
+# 3. Lancer l'app
+python app.py
+```
+
+**Résultat attendu** :
+```
+Running on local URL:  http://127.0.0.1:7860
+```
+
+Ouvrez http://localhost:7860 dans votre navigateur.
+
+---
+
+## 📋 Checklist de Déploiement
+
+### Avant de Déployer
+
+- [ ] Dépendances installées localement (`pip install -r requirements.txt`)
+- [ ] App testée localement (`python app.py` fonctionne)
+- [ ] Interface Gradio accessible sur http://localhost:7860
+- [ ] Space créé sur Hugging Face
+
+### Déploiement
+
+**Méthode Simple (Interface Web)** :
+- [ ] Aller sur https://huggingface.co/spaces/jojonocode/Scrap-Dji
+- [ ] Cliquer "Files" → "Add file" → "Upload files"
+- [ ] Uploader tous les fichiers du projet
+- [ ] Commit
+
+**OU Méthode Git** :
+- [ ] Installer `huggingface_hub` : `pip install huggingface_hub`
+- [ ] Login : `huggingface-cli login`
+- [ ] Cloner : `huggingface-cli repo clone spaces/jojonocode/Scrap-Dji`
+- [ ] Copier les fichiers
+- [ ] Push
+
+### Après Déploiement
+
+- [ ] Vérifier les logs dans l'onglet "Logs"
+- [ ] Attendre le status "Running"
+- [ ] Tester l'interface : https://huggingface.co/spaces/jojonocode/Scrap-Dji
+- [ ] Tester l'API : https://jojonocode-scrap-dji.hf.space/api/health
+
+---
+
+## 🆘 Problèmes Courants
+
+### "Space not found"
+→ Vérifiez que le Space existe : https://huggingface.co/spaces/jojonocode/Scrap-Dji
+
+### "Build failed"
+→ Vérifiez les logs dans l'onglet "Logs" du Space
+
+### "Module not found" sur HF
+→ Vérifiez que `requirements.txt` est bien uploadé
+
+### "Permission denied"
+→ Vérifiez que le Space est bien sous votre compte `jojonocode`
+
+---
+
+## 💡 Recommandation Finale
+
+**Utilisez l'interface web Hugging Face** pour uploader les fichiers, c'est :
+- ✅ Plus simple
+- ✅ Pas de problème d'authentification
+- ✅ Pas besoin de Git
+- ✅ Drag & drop des fichiers
+
+**Lien direct** : https://huggingface.co/spaces/jojonocode/Scrap-Dji/tree/main
+
+Cliquez sur "Add file" et uploadez tout ! 🚀

VALUE_PROPOSITION.md

@@ -0,0 +1,27 @@
+# Scrap-Dji : Proposition de Valeur Stratégique
+
+## 🎯 Pertinence du Cas (Le Problème Africain)
+
+**Le "Data Gap" Structurel :**
+Dans l'écosystème numérique mondial, l'Afrique souffre d'un déficit chronique de données structurées. 
+*   **Fragmentation :** Les informations locales (actualités, tendances sociales, documents officiels) sont éparpillées sur des milliers de sites web, forums et réseaux sociaux, souvent mal référencés par les moteurs de recherche géants (Google/Bing).
+*   **Invisibilité pour l'IA :** Les grands modèles d'IA (LLMs) sont entraînés majoritairement sur des données occidentales. Ils "hallucinent" ou manquent de contexte sur les réalités africaines car la donnée brute n'est pas accessible ou normalisée.
+
+**Scrap-Dji** ne se contente pas de collecter la donnée ; il **structure le chaos numérique local** pour le rendre exploitable. Il répond au besoin critique de disposer d'une donnée propre, traçable et centralisée pour la prise de décision en Afrique.
+
+---
+
+## 🚀 Le Point Central d'Argument "Imbattable"
+
+**"L'Infrastructure de Souveraineté Numérique pour l'IA Africaine"**
+
+L'argument qui tue n'est pas technologique, il est **stratégique** :
+
+> **Scrap-Dji n'est pas un simple outil de scraping, c'est le "Système Nerveux" de la future intelligence artificielle africaine.**
+
+**Pourquoi c'est imbattable :**
+1.  **Souveraineté de la Donnée :** Contrairement à l'utilisation d'API tierces (qui peuvent couper l'accès ou augmenter les prix), Scrap-Dji vous rend **propriétaire** de votre lac de données (Data Lake). Vous ne dépendez de personne pour accéder à l'information stratégique du continent.
+2.  **Prêt pour le Futur (AI-Ready) :** Grâce à son architecture intégrant nativement les **bases de données vectorielles (Qdrant/Typesense)**, Scrap-Dji transforme instantanément le contenu collecté en vecteurs sémantiques.
+    *   *Conséquence :* Vous pouvez brancher directement un LLM (comme Llama 3 ou Mistral) dessus pour créer un "ChatGPT Africain" qui connaît *réellement* l'actualité locale, les lois sénégalaises ou les tendances togolaises en temps réel.
+
+**En résumé :** C'est la brique fondamentale qui manque à tout projet technologique sérieux en Afrique : **La maîtrise de la donnée source.** Sans Scrap-Dji, vous construisez des châteaux sur du sable ; avec Scrap-Dji, vous construisez sur des fondations de béton armé.

api/__init__.py

@@ -0,0 +1 @@
+# Backend API : FastAPI 

api/main.py

@@ -0,0 +1,74 @@
+from fastapi import FastAPI, Query
+from fastapi.middleware.cors import CORSMiddleware
+from typing import List, Optional
+import os
+import typesense
+from utils.config import TYPESENSE_HOST, TYPESENSE_PORT, TYPESENSE_API_KEY
+from db.postgres_connector import SessionLocal
+from db.models import Document
+from functools import lru_cache
+
+app = FastAPI(title="Scrap-Dji Turbo API")
+
+# Configuration CORS pour permettre les requêtes depuis le frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # En production, spécifier les domaines autorisés
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Cache LRU pour les requêtes ultra-fréquentes (Zéro latence)
+@lru_cache(maxsize=100)
+def get_cached_search(q: str, pays: Optional[str]):
+    # Cette fonction est appelée par le endpoint async
+    return None # Placeholder pour la logique interne
+
+ts_client = typesense.Client({
+    'nodes': [{'host': TYPESENSE_HOST, 'port': TYPESENSE_PORT, 'protocol': 'http'}],
+    'api_key': TYPESENSE_API_KEY,
+    'connection_timeout_seconds': 1
+})
+
+SEARCH_CACHE = {}
+
+@app.get("/search")
+async def search(q: str = Query(...), pays: Optional[str] = None):
+    # Check simple cache manuel (plus rapide pour l'async)
+    cache_key = f"{q}_{pays}"
+    if cache_key in SEARCH_CACHE:
+        return SEARCH_CACHE[cache_key]
+
+    try:
+        res = ts_client.collections['documents'].documents.search({
+            'q': q, 
+            'query_by': 'titre,texte',
+            'filter_by': f'pays:={pays}' if pays else ''
+        })
+        hits = res['hits']
+        SEARCH_CACHE[cache_key] = hits # Mise en cache
+        return hits
+    except:
+        # Fallback final : Recherche dans le fichier JSON local (Mode Test)
+        local_file = "data/search_index.json"
+        if os.path.exists(local_file):
+            import json
+            with open(local_file, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                results = [d for d in data if q.lower() in d['titre'].lower() or q.lower() in d['texte'].lower()]
+                if pays:
+                    results = [d for d in results if d.get('pays') == pays]
+                return results[:10]
+        
+        # Fallback SQL Optimisé (Indexé) - essayera quand même si Postgres est là
+        try:
+            session = SessionLocal()
+            results = session.query(Document).filter(Document.titre.ilike(f"%{q}%")).limit(5).all()
+            session.close()
+            return results
+        except:
+            return []
+
+@app.get("/health")
+def health(): return {"status": "turbo-charged"}

app.py

@@ -0,0 +1,599 @@
+#!/usr/bin/env python3
+"""
+Scrap-Dji - Application Hugging Face Spaces
+Combine FastAPI (endpoints pour frontend) + Gradio (interface web)
+"""
+
+import os
+import json
+import asyncio
+from datetime import datetime
+from typing import List, Optional, Dict, Any
+from pathlib import Path
+
+# FastAPI
+from fastapi import FastAPI, Query, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+
+# Gradio
+import gradio as gr
+
+# Scraper
+from scraper.main import ScrapDjiScraper
+from utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+# ============================================================================
+# CONFIGURATION
+# ============================================================================
+
+DATA_DIR = Path("/data") if os.path.exists("/data") else Path("./data")
+DATA_DIR.mkdir(exist_ok=True)
+DOCUMENTS_FILE = DATA_DIR / "documents.json"
+SOURCES_FILE = Path("sources.json")
+
+# ============================================================================
+# FASTAPI APP - Endpoints pour Frontend
+# ============================================================================
+
+app = FastAPI(
+    title="Scrap-Dji API",
+    description="API de recherche et scraping de contenus africains",
+    version="2.0.0"
+)
+
+# CORS pour permettre les requêtes depuis n'importe quel frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ============================================================================
+# MODELS
+# ============================================================================
+
+class SearchRequest(BaseModel):
+    query: str
+    pays: Optional[str] = None
+    langue: Optional[str] = None
+    limit: int = 10
+    fuzzy: bool = True
+
+class SearchResponse(BaseModel):
+    total: int
+    results: List[Dict[str, Any]]
+    query: str
+    execution_time_ms: float
+
+class StatsResponse(BaseModel):
+    total_documents: int
+    pays: Dict[str, int]
+    langues: Dict[str, int]
+    sources: Dict[str, int]
+    derniere_mise_a_jour: Optional[str]
+
+# ============================================================================
+# SEARCH ENGINE - Recherche locale optimisée
+# ============================================================================
+
+class LocalSearchEngine:
+    """Moteur de recherche local ultra-rapide avec fuzzy matching"""
+    
+    def __init__(self, documents_file: Path):
+        self.documents_file = documents_file
+        self.documents = []
+        self.load_documents()
+    
+    def load_documents(self):
+        """Charge les documents depuis le fichier JSON"""
+        if self.documents_file.exists():
+            try:
+                with open(self.documents_file, 'r', encoding='utf-8') as f:
+                    self.documents = json.load(f)
+                logger.info(f"✅ {len(self.documents)} documents chargés")
+            except Exception as e:
+                logger.error(f"Erreur chargement documents: {e}")
+                self.documents = []
+        else:
+            self.documents = []
+    
+    def reload(self):
+        """Recharge les documents (après scraping)"""
+        self.load_documents()
+    
+    def fuzzy_match(self, text: str, query: str, threshold: float = 0.6) -> bool:
+        """Fuzzy matching simple basé sur la distance de Levenshtein"""
+        text = text.lower()
+        query = query.lower()
+        
+        # Recherche exacte d'abord
+        if query in text:
+            return True
+        
+        # Fuzzy matching pour les mots individuels
+        query_words = query.split()
+        text_words = text.split()
+        
+        for q_word in query_words:
+            for t_word in text_words:
+                # Calcul de similarité simple
+                if len(q_word) < 3:
+                    if q_word == t_word:
+                        return True
+                else:
+                    # Tolérance aux fautes pour mots > 3 caractères
+                    if self._similarity(q_word, t_word) >= threshold:
+                        return True
+        
+        return False
+    
+    def _similarity(self, s1: str, s2: str) -> float:
+        """Calcule la similarité entre deux chaînes (0-1)"""
+        if s1 == s2:
+            return 1.0
+        
+        # Distance de Levenshtein simplifiée
+        len_s1, len_s2 = len(s1), len(s2)
+        if abs(len_s1 - len_s2) > 2:
+            return 0.0
+        
+        # Compte les caractères communs
+        common = sum(1 for a, b in zip(s1, s2) if a == b)
+        max_len = max(len_s1, len_s2)
+        
+        return common / max_len if max_len > 0 else 0.0
+    
+    def search(
+        self,
+        query: str,
+        pays: Optional[str] = None,
+        langue: Optional[str] = None,
+        limit: int = 10,
+        fuzzy: bool = True
+    ) -> List[Dict[str, Any]]:
+        """Recherche dans les documents avec scoring"""
+        
+        results = []
+        query_lower = query.lower()
+        
+        for doc in self.documents:
+            score = 0.0
+            
+            # Filtres
+            if pays and doc.get('pays') != pays:
+                continue
+            if langue and doc.get('langue') != langue:
+                continue
+            
+            # Scoring
+            titre = doc.get('titre', '')
+            texte = doc.get('texte', '')
+            
+            if fuzzy:
+                # Recherche permissive
+                if self.fuzzy_match(titre, query):
+                    score += 10.0  # Boost titre
+                if self.fuzzy_match(texte, query):
+                    score += 5.0
+            else:
+                # Recherche exacte
+                if query_lower in titre.lower():
+                    score += 10.0
+                if query_lower in texte.lower():
+                    score += 5.0
+            
+            # Boost par pertinence
+            if 'tags' in doc:
+                for tag in doc.get('tags', []):
+                    if query_lower in tag.lower():
+                        score += 3.0
+            
+            if score > 0:
+                results.append({
+                    **doc,
+                    '_score': score
+                })
+        
+        # Tri par score décroissant
+        results.sort(key=lambda x: x['_score'], reverse=True)
+        
+        return results[:limit]
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Retourne les statistiques de la base"""
+        pays_count = {}
+        langues_count = {}
+        sources_count = {}
+        
+        for doc in self.documents:
+            # Pays
+            pays = doc.get('pays', 'Inconnu')
+            pays_count[pays] = pays_count.get(pays, 0) + 1
+            
+            # Langues
+            langue = doc.get('langue', 'Inconnu')
+            langues_count[langue] = langues_count.get(langue, 0) + 1
+            
+            # Sources
+            source_url = doc.get('source_url', '')
+            if source_url:
+                domain = source_url.split('/')[2] if len(source_url.split('/')) > 2 else 'Inconnu'
+                sources_count[domain] = sources_count.get(domain, 0) + 1
+        
+        return {
+            'total_documents': len(self.documents),
+            'pays': pays_count,
+            'langues': langues_count,
+            'sources': sources_count,
+            'derniere_mise_a_jour': datetime.now().isoformat()
+        }
+
+# Instance globale du moteur de recherche
+search_engine = LocalSearchEngine(DOCUMENTS_FILE)
+
+# ============================================================================
+# API ENDPOINTS
+# ============================================================================
+
+@app.get("/")
+async def root():
+    """Endpoint racine"""
+    return {
+        "name": "Scrap-Dji API",
+        "version": "2.0.0",
+        "description": "API de recherche et scraping de contenus africains",
+        "endpoints": {
+            "search": "/api/search",
+            "stats": "/api/stats",
+            "documents": "/api/documents",
+            "health": "/api/health"
+        }
+    }
+
+@app.get("/api/health")
+async def health():
+    """Health check"""
+    return {
+        "status": "healthy",
+        "documents_loaded": len(search_engine.documents),
+        "timestamp": datetime.now().isoformat()
+    }
+
+@app.post("/api/search", response_model=SearchResponse)
+async def api_search(request: SearchRequest):
+    """
+    Endpoint de recherche principal
+    
+    **Paramètres:**
+    - query: Texte à rechercher
+    - pays: Filtrer par pays (optionnel)
+    - langue: Filtrer par langue (optionnel)
+    - limit: Nombre de résultats (défaut: 10)
+    - fuzzy: Recherche permissive avec tolérance aux fautes (défaut: true)
+    
+    **Exemple:**
+    ```json
+    {
+        "query": "économie togo",
+        "pays": "Togo",
+        "limit": 20,
+        "fuzzy": true
+    }
+    ```
+    """
+    start_time = datetime.now()
+    
+    results = search_engine.search(
+        query=request.query,
+        pays=request.pays,
+        langue=request.langue,
+        limit=request.limit,
+        fuzzy=request.fuzzy
+    )
+    
+    execution_time = (datetime.now() - start_time).total_seconds() * 1000
+    
+    return SearchResponse(
+        total=len(results),
+        results=results,
+        query=request.query,
+        execution_time_ms=round(execution_time, 2)
+    )
+
+@app.get("/api/search", response_model=SearchResponse)
+async def api_search_get(
+    q: str = Query(..., description="Texte à rechercher"),
+    pays: Optional[str] = Query(None, description="Filtrer par pays"),
+    langue: Optional[str] = Query(None, description="Filtrer par langue"),
+    limit: int = Query(10, ge=1, le=100, description="Nombre de résultats"),
+    fuzzy: bool = Query(True, description="Recherche permissive")
+):
+    """
+    Endpoint de recherche (GET)
+    
+    **Exemple:** `/api/search?q=économie&pays=Togo&limit=20`
+    """
+    request = SearchRequest(
+        query=q,
+        pays=pays,
+        langue=langue,
+        limit=limit,
+        fuzzy=fuzzy
+    )
+    return await api_search(request)
+
+@app.get("/api/stats", response_model=StatsResponse)
+async def api_stats():
+    """
+    Retourne les statistiques de la base de données
+    
+    **Retourne:**
+    - total_documents: Nombre total de documents
+    - pays: Répartition par pays
+    - langues: Répartition par langue
+    - sources: Répartition par source
+    """
+    stats = search_engine.get_stats()
+    return StatsResponse(**stats)
+
+@app.get("/api/documents")
+async def api_documents(
+    skip: int = Query(0, ge=0),
+    limit: int = Query(10, ge=1, le=100)
+):
+    """
+    Retourne la liste des documents (paginée)
+    
+    **Paramètres:**
+    - skip: Nombre de documents à sauter
+    - limit: Nombre de documents à retourner
+    """
+    documents = search_engine.documents[skip:skip+limit]
+    return {
+        "total": len(search_engine.documents),
+        "skip": skip,
+        "limit": limit,
+        "documents": documents
+    }
+
+@app.get("/api/documents/{doc_id}")
+async def api_document_by_id(doc_id: str):
+    """Retourne un document par son ID"""
+    for doc in search_engine.documents:
+        if doc.get('id') == doc_id:
+            return doc
+    raise HTTPException(status_code=404, detail="Document non trouvé")
+
+@app.post("/api/reload")
+async def api_reload():
+    """Recharge les documents depuis le fichier (après scraping)"""
+    search_engine.reload()
+    return {
+        "status": "success",
+        "documents_loaded": len(search_engine.documents)
+    }
+
+# ============================================================================
+# GRADIO INTERFACE
+# ============================================================================
+
+def gradio_search(query: str, pays: str, langue: str, fuzzy: bool):
+    """Fonction de recherche pour Gradio"""
+    if not query:
+        return "⚠️ Veuillez entrer une requête de recherche"
+    
+    results = search_engine.search(
+        query=query,
+        pays=pays if pays != "Tous" else None,
+        langue=langue if langue != "Toutes" else None,
+        limit=20,
+        fuzzy=fuzzy
+    )
+    
+    if not results:
+        return f"❌ Aucun résultat pour '{query}'"
+    
+    # Formatage des résultats
+    output = f"## 🔍 Résultats pour '{query}' ({len(results)} trouvés)\n\n"
+    
+    for i, doc in enumerate(results, 1):
+        titre = doc.get('titre', 'Sans titre')
+        texte = doc.get('texte', '')[:200] + "..."
+        pays_doc = doc.get('pays', 'Inconnu')
+        source = doc.get('source_url', '')
+        score = doc.get('_score', 0)
+        
+        output += f"### {i}. {titre}\n"
+        output += f"**Pays:** {pays_doc} | **Score:** {score:.1f}\n\n"
+        output += f"{texte}\n\n"
+        output += f"[🔗 Source]({source})\n\n"
+        output += "---\n\n"
+    
+    return output
+
+def gradio_stats():
+    """Affiche les statistiques pour Gradio"""
+    stats = search_engine.get_stats()
+    
+    output = "# 📊 Statistiques de la Base de Données\n\n"
+    output += f"**Total de documents:** {stats['total_documents']}\n\n"
+    
+    output += "## 🌍 Répartition par Pays\n\n"
+    for pays, count in sorted(stats['pays'].items(), key=lambda x: x[1], reverse=True):
+        output += f"- **{pays}:** {count} documents\n"
+    
+    output += "\n## 🗣️ Répartition par Langue\n\n"
+    for langue, count in sorted(stats['langues'].items(), key=lambda x: x[1], reverse=True):
+        output += f"- **{langue}:** {count} documents\n"
+    
+    output += "\n## 📰 Répartition par Source\n\n"
+    for source, count in sorted(stats['sources'].items(), key=lambda x: x[1], reverse=True)[:10]:
+        output += f"- **{source}:** {count} documents\n"
+    
+    return output
+
+async def gradio_scrape(progress=gr.Progress()):
+    """Lance le scraping pour Gradio"""
+    progress(0, desc="Initialisation du scraping...")
+    
+    try:
+        scraper = ScrapDjiScraper(str(SOURCES_FILE))
+        
+        progress(0.3, desc="Scraping en cours...")
+        await scraper.run()
+        
+        progress(0.8, desc="Rechargement des documents...")
+        search_engine.reload()
+        
+        progress(1.0, desc="Terminé!")
+        
+        stats = search_engine.get_stats()
+        return f"✅ Scraping terminé!\n\n**{stats['total_documents']} documents** dans la base"
+    
+    except Exception as e:
+        logger.error(f"Erreur scraping: {e}")
+        return f"❌ Erreur lors du scraping: {str(e)}"
+
+# Interface Gradio
+with gr.Blocks(title="Scrap-Dji - Base de Connaissance Panafricaine", theme=gr.themes.Soft()) as gradio_app:
+    
+    gr.Markdown("""
+    # 🌍 Scrap-Dji - Base de Connaissance Panafricaine
+    
+    Système de scraping et de recherche de contenus africains (Togo, Bénin, Afrique)
+    """)
+    
+    with gr.Tabs():
+        
+        # ONGLET RECHERCHE
+        with gr.Tab("🔍 Recherche"):
+            gr.Markdown("### Recherchez dans la base de données")
+            
+            with gr.Row():
+                search_query = gr.Textbox(
+                    label="Requête de recherche",
+                    placeholder="Ex: économie togo, politique bénin...",
+                    scale=3
+                )
+                search_btn = gr.Button("🔍 Rechercher", variant="primary", scale=1)
+            
+            with gr.Row():
+                search_pays = gr.Dropdown(
+                    choices=["Tous", "Togo", "Bénin", "Afrique"],
+                    value="Tous",
+                    label="Pays"
+                )
+                search_langue = gr.Dropdown(
+                    choices=["Toutes", "fr", "en"],
+                    value="Toutes",
+                    label="Langue"
+                )
+                search_fuzzy = gr.Checkbox(
+                    value=True,
+                    label="Recherche permissive (tolérance aux fautes)"
+                )
+            
+            search_output = gr.Markdown()
+            
+            search_btn.click(
+                fn=gradio_search,
+                inputs=[search_query, search_pays, search_langue, search_fuzzy],
+                outputs=search_output
+            )
+        
+        # ONGLET SCRAPING
+        with gr.Tab("🚀 Scraping"):
+            gr.Markdown("### Lancer le scraping des sources")
+            
+            scrape_btn = gr.Button("🚀 Lancer le Scraping", variant="primary", size="lg")
+            scrape_output = gr.Markdown()
+            
+            scrape_btn.click(
+                fn=gradio_scrape,
+                outputs=scrape_output
+            )
+        
+        # ONGLET STATISTIQUES
+        with gr.Tab("📊 Statistiques"):
+            gr.Markdown("### Statistiques de la base de données")
+            
+            stats_btn = gr.Button("📊 Actualiser les Statistiques", variant="primary")
+            stats_output = gr.Markdown()
+            
+            stats_btn.click(
+                fn=gradio_stats,
+                outputs=stats_output
+            )
+        
+        # ONGLET API
+        with gr.Tab("🔌 API"):
+            gr.Markdown("""
+            ### Endpoints API disponibles
+            
+            L'API REST est accessible pour intégration dans votre frontend:
+            
+            #### 🔍 Recherche
+            ```
+            POST /api/search
+            GET  /api/search?q=query&pays=Togo&limit=20
+            ```
+            
+            #### 📊 Statistiques
+            ```
+            GET /api/stats
+            ```
+            
+            #### 📄 Documents
+            ```
+            GET /api/documents?skip=0&limit=10
+            GET /api/documents/{id}
+            ```
+            
+            #### 🔄 Rechargement
+            ```
+            POST /api/reload
+            ```
+            
+            #### ❤️ Health Check
+            ```
+            GET /api/health
+            ```
+            
+            ---
+            
+            **Documentation interactive:** [/docs](/docs)
+            
+            **Exemple de requête:**
+            ```bash
+            curl -X POST "https://YOUR_SPACE.hf.space/api/search" \\
+              -H "Content-Type: application/json" \\
+              -d '{"query": "économie togo", "limit": 10, "fuzzy": true}'
+            ```
+            """)
+
+# ============================================================================
+# MONTAGE GRADIO DANS FASTAPI
+# ============================================================================
+
+# Monter l'interface Gradio dans FastAPI
+app = gr.mount_gradio_app(app, gradio_app, path="/")
+
+# ============================================================================
+# MAIN
+# ============================================================================
+
+if __name__ == "__main__":
+    import uvicorn
+    
+    # Lancement de l'application
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=7860,  # Port par défaut pour Hugging Face Spaces
+        log_level="info"
+    )

config.env.example

@@ -0,0 +1,28 @@
+# === Config Optimisée pour Faible Machine ===
+
+# PostgreSQL (Requis pour la structure)
+POSTGRES_URI=postgresql://user:password@localhost:5432/scrapdji
+
+# MongoDB (Optionnel si vous n'avez pas assez de RAM)
+MONGO_URI=mongodb://localhost:27017
+MONGO_DB=scrapdji
+
+# Stockage (Optimisation : local suffisant)
+STORAGE_PATH=./storage_data
+
+# Recherche (Typesense est TRÈS léger par rapport à ElasticSearch)
+TYPESENSE_HOST=localhost
+TYPESENSE_PORT=8108
+TYPESENSE_API_KEY=xyz
+
+# Qdrant (Désactivez si vous n'avez pas de GPU ou de RAM)
+QDRANT_HOST=localhost
+QDRANT_PORT=6333
+
+# --- PARAMÈTRES DE PERFORMANCE ---
+# Délai entre requêtes (1s pour ne pas saturer le CPU)
+SCRAPER_DELAY=1
+# Nombre de requêtes simultanées (Réduisez à 4-8 si la RAM est < 2GB)
+SCRAPER_CONCURRENT_REQUESTS=8
+# Niveau de log (WARNING réduit les écritures disque)
+LOG_LEVEL=WARNING

datasets/ewe/README.md

@@ -0,0 +1,18 @@
+# Dataset Ewe (Végbé)
+
+Ce dossier contient les données pour l'entraînement et le finetune de modèles LLM/SLM sur la langue Ewe (Togo, Ghana, Bénin).
+
+## Structure des sous-dossiers
+- `raw/` : données brutes collectées (tous formats)
+- `clean/` : données nettoyées, formatées
+- `annotated/` : données enrichies (tags, traductions, métadonnées)
+- `final/` : corpus prêt à l'entraînement (JSONL, Parquet...)
+
+## Bonnes pratiques
+- Diversité des sources (oral, écrit, médias, réseaux sociaux...)
+- Respect de la vie privée, anonymisation
+- Annotation thématique et contextuelle
+- Traductions si possible (français, anglais)
+
+## Exemple de schéma JSONL
+Voir le fichier `final/ewe_corpus.schema.json` pour la structure détaillée. 

datasets/ewe/annotated/.gitkeep

@@ -0,0 +1 @@
+ 

datasets/ewe/clean/.gitkeep

@@ -0,0 +1 @@
+ 

datasets/ewe/final/ewe_corpus.jsonl

@@ -0,0 +1 @@
+ 

datasets/ewe/final/ewe_corpus.schema.json

@@ -0,0 +1,90 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "title": "EweCorpusEntry",
+    "type": "object",
+    "properties": {
+        "id": {
+            "type": "string",
+            "description": "UUID unique"
+        },
+        "source": {
+            "type": "string",
+            "description": "Type/source du contenu"
+        },
+        "titre": {
+            "type": [
+                "string",
+                "null"
+            ],
+            "description": "Titre ou contexte"
+        },
+        "texte": {
+            "type": "string",
+            "description": "Contenu principal en Ewe"
+        },
+        "langue": {
+            "type": "string",
+            "enum": [
+                "ewe"
+            ]
+        },
+        "pays": {
+            "type": "string",
+            "enum": [
+                "Togo",
+                "Ghana",
+                "Bénin"
+            ]
+        },
+        "type": {
+            "type": "string",
+            "description": "Catégorie du texte"
+        },
+        "auteur": {
+            "type": [
+                "string",
+                "null"
+            ],
+            "description": "Auteur ou pseudo"
+        },
+        "date": {
+            "type": [
+                "string",
+                "null"
+            ],
+            "description": "Date ISO"
+        },
+        "tags": {
+            "type": "array",
+            "items": {
+                "type": "string"
+            }
+        },
+        "traduction": {
+            "type": [
+                "string",
+                "null"
+            ],
+            "description": "Traduction FR/EN"
+        },
+        "metadonnees": {
+            "type": [
+                "object",
+                "null"
+            ]
+        },
+        "hash": {
+            "type": "string",
+            "description": "SHA256 du texte"
+        }
+    },
+    "required": [
+        "id",
+        "source",
+        "texte",
+        "langue",
+        "pays",
+        "type",
+        "hash"
+    ]
+}

datasets/ewe/raw/.gitkeep

@@ -0,0 +1 @@
+ 

db/__init__.py

@@ -0,0 +1 @@
+# Module de base de données : connecteurs PostgreSQL & MongoDB 

db/models.py

@@ -0,0 +1,60 @@
+# Modèles de base de données pour Scrap-Dji
+from sqlalchemy import Column, String, Text, DateTime, ForeignKey, Table
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.ext.declarative import declarative_base
+import datetime
+
+Base = declarative_base()
+
+class Document(Base):
+    __tablename__ = 'documents'
+    id = Column(UUID(as_uuid=True), primary_key=True)
+    titre = Column(String)
+    texte = Column(Text)
+    langue = Column(String)
+    type_document = Column(String)
+    auteur = Column(String)
+    source_url = Column(String)
+    tags = Column(String)
+    pays = Column(String)
+    date = Column(DateTime, default=datetime.datetime.utcnow)
+
+class DocumentVersion(Base):
+    __tablename__ = 'document_versions'
+    id = Column(UUID(as_uuid=True), primary_key=True)
+    document_id = Column(UUID(as_uuid=True), ForeignKey('documents.id'))
+    texte = Column(Text)
+    date = Column(DateTime, default=datetime.datetime.utcnow)
+
+class Image(Base):
+    __tablename__ = 'images'
+    id = Column(UUID(as_uuid=True), primary_key=True)
+    document_id = Column(UUID(as_uuid=True), ForeignKey('documents.id'))
+    image_hash = Column(String)
+    chemin = Column(String)
+
+class LienExterne(Base):
+    __tablename__ = 'liens_externes'
+    id = Column(UUID(as_uuid=True), primary_key=True)
+    document_id = Column(UUID(as_uuid=True), ForeignKey('documents.id'))
+    url = Column(String)
+
+# Schémas Pydantic pour MongoDB (NoSQL)
+from pydantic import BaseModel, Field
+from typing import List, Optional
+
+class MongoDocument(BaseModel):
+    uuid: str
+    titre: str
+    texte: str
+    langue: str
+    type_document: str
+    auteur: Optional[str]
+    source_url: Optional[str]
+    tags: Optional[List[str]]
+    pays: Optional[str]
+    date: Optional[str]
+    images: Optional[List[str]]
+    liens_externes: Optional[List[str]]
+    versions: Optional[List[dict]]
+    metadonnees: Optional[dict] 

db/mongo_connector.py

@@ -0,0 +1,17 @@
+from motor.motor_asyncio import AsyncIOMotorClient
+from utils.config import MONGO_URI, MONGO_DB
+
+client = AsyncIOMotorClient(MONGO_URI)
+db = client[MONGO_DB]
+
+async def save_to_mongo(collection: str, document: dict):
+    """Sauvegarde un document de manière asynchrone dans MongoDB"""
+    try:
+        await db[collection].update_one(
+            {"source_url": document["source_url"]},
+            {"$set": document},
+            upsert=True
+        )
+        return True
+    except Exception:
+        return False

db/postgres_connector.py

@@ -0,0 +1,10 @@
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from .models import Base
+from utils.config import POSTGRES_URI
+
+engine = create_engine(POSTGRES_URI)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+def init_db():
+    Base.metadata.create_all(bind=engine) 

frontend/README.md

@@ -0,0 +1,7 @@
+# Frontend
+
+Interface utilisateur pour la recherche et la visualisation des résultats.
+
+- Champ de recherche
+- Filtres (pays, date, source, type)
+- Affichage des résultats + images 

frontend/index.html

@@ -0,0 +1,428 @@
+<!DOCTYPE html>
+<html lang="fr" class="dark">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Scrap-Dji</title>
+    <style>
+        :root {
+            /* OpenAI / Apple Dark Mode Palette */
+            --bg-primary: #000000;
+            --bg-secondary: #121212;
+            --text-primary: #ffffff;
+            --text-secondary: #8e8e8e;
+            --accent: #3b82f6;
+            /* Subtle Blue Like Apple */
+            --border: #333333;
+            --hover: #1f1f1f;
+            --font-main: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+            --transition: all 0.3s cubic-bezier(0.25, 0.8, 0.25, 1);
+        }
+
+        * {
+            box-sizing: border-box;
+            margin: 0;
+            padding: 0;
+            outline: none;
+        }
+
+        body {
+            background-color: var(--bg-primary);
+            color: var(--text-primary);
+            font-family: var(--font-main);
+            min-height: 100vh;
+            display: flex;
+            flex-direction: column;
+            overflow-x: hidden;
+        }
+
+        /* --- Header / Navigation --- */
+        nav {
+            position: fixed;
+            top: 0;
+            width: 100%;
+            padding: 20px 40px;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            z-index: 100;
+            background: rgba(0, 0, 0, 0.8);
+            backdrop-filter: blur(20px);
+            transition: var(--transition);
+        }
+
+        .logo {
+            font-size: 1.2rem;
+            font-weight: 700;
+            letter-spacing: -0.5px;
+            color: var(--text-primary);
+            text-decoration: none;
+            opacity: 0.9;
+        }
+
+        /* --- Main Layout --- */
+        main {
+            flex: 1;
+            display: flex;
+            flex-direction: column;
+            justify-content: center;
+            align-items: center;
+            padding: 20px;
+            transition: var(--transition);
+            min-height: 100vh;
+        }
+
+        /* Transition state: Results Mode */
+        body.has-results main {
+            justify-content: flex-start;
+            padding-top: 100px;
+            min-height: auto;
+        }
+
+        /* --- Search Container --- */
+        .search-container {
+            width: 100%;
+            max-width: 680px;
+            text-align: center;
+            transition: var(--transition);
+        }
+
+        body.has-results .search-container {
+            position: fixed;
+            top: 15px;
+            left: 50%;
+            transform: translateX(-50%);
+            width: 50%;
+            max-width: 600px;
+            z-index: 101;
+            margin: 0;
+        }
+
+        h1 {
+            font-size: 3rem;
+            font-weight: 600;
+            letter-spacing: -1.5px;
+            margin-bottom: 40px;
+            transition: var(--transition);
+        }
+
+        body.has-results h1 {
+            opacity: 0;
+            pointer-events: none;
+            position: absolute;
+            transform: scale(0.9);
+        }
+
+        /* --- Search Input --- */
+        .input-wrapper {
+            position: relative;
+            background: var(--bg-secondary);
+            border: 1px solid var(--border);
+            border-radius: 16px;
+            /* Apple rounded corners */
+            padding: 6px;
+            display: flex;
+            align-items: center;
+            box-shadow: 0 4px 20px rgba(0, 0, 0, 0.4);
+            transition: var(--transition);
+        }
+
+        .input-wrapper:focus-within {
+            border-color: #555;
+            background: #1a1a1a;
+            box-shadow: 0 8px 30px rgba(0, 0, 0, 0.6);
+        }
+
+        .search-icon {
+            padding: 0 15px;
+            color: var(--text-secondary);
+        }
+
+        input[type="text"] {
+            flex: 1;
+            background: transparent;
+            border: none;
+            padding: 14px 0;
+            font-size: 1.1rem;
+            color: var(--text-primary);
+            font-weight: 400;
+        }
+
+        input[type="text"]::placeholder {
+            color: #555;
+        }
+
+        /* Filter Select - Minimalist */
+        select {
+            background: transparent;
+            border: none;
+            color: var(--text-secondary);
+            font-size: 0.9rem;
+            padding: 0 15px;
+            cursor: pointer;
+            transition: color 0.2s;
+            margin-right: 10px;
+            border-left: 1px solid var(--border);
+        }
+
+        select:hover {
+            color: var(--text-primary);
+        }
+
+        /* --- Key Visual Hints --- */
+        .shortcuts {
+            margin-top: 20px;
+            font-size: 0.85rem;
+            color: #444;
+            transition: var(--transition);
+        }
+
+        body.has-results .shortcuts {
+            opacity: 0;
+        }
+
+        /* --- Results Area --- */
+        #results {
+            width: 100%;
+            max-width: 680px;
+            margin-top: 40px;
+            opacity: 0;
+            transform: translateY(20px);
+            transition: opacity 0.4s ease 0.2s, transform 0.4s ease 0.2s;
+        }
+
+        body.has-results #results {
+            opacity: 1;
+            transform: translateY(0);
+        }
+
+        /* --- Result Card (Apple-style) --- */
+        .result-card {
+            padding: 20px 0;
+            border-bottom: 1px solid #1a1a1a;
+            transition: var(--transition);
+            animation: fadeIn 0.5s ease forwards;
+        }
+
+        .result-card:last-child {
+            border-bottom: none;
+        }
+
+        /* Source URL */
+        .source-pill {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            font-size: 0.85rem;
+            color: var(--text-secondary);
+            margin-bottom: 8px;
+        }
+
+        .source-icon {
+            width: 16px;
+            height: 16px;
+            background: #333;
+            border-radius: 50%;
+        }
+
+        .result-card h3 {
+            font-size: 1.25rem;
+            font-weight: 500;
+            color: #3b82f6;
+            /* Modern Blue Link */
+            margin-bottom: 8px;
+            letter-spacing: -0.01em;
+            cursor: pointer;
+        }
+
+        .result-card h3:hover {
+            text-decoration: underline;
+        }
+
+        .result-card p {
+            font-size: 0.95rem;
+            line-height: 1.6;
+            color: #b0b0b0;
+        }
+
+        .meta-tag {
+            display: inline-block;
+            margin-top: 10px;
+            font-size: 0.75rem;
+            padding: 2px 8px;
+            border-radius: 4px;
+            background: #1a1a1a;
+            color: #666;
+            border: 1px solid #222;
+        }
+
+        @keyframes fadeIn {
+            from {
+                opacity: 0;
+                transform: translateY(10px);
+            }
+
+            to {
+                opacity: 1;
+                transform: translateY(0);
+            }
+        }
+
+        /* --- Mobile --- */
+        @media (max-width: 768px) {
+            h1 {
+                font-size: 2rem;
+            }
+
+            body.has-results .search-container {
+                width: 90%;
+                max-width: none;
+                top: 10px;
+            }
+
+            body.has-results main {
+                padding-top: 90px;
+            }
+
+            .input-wrapper {
+                padding: 4px;
+            }
+        }
+    </style>
+</head>
+
+<body>
+
+    <nav>
+        <a href="#" class="logo" onclick="resetApp()">Scrap-Dji</a>
+    </nav>
+
+    <main>
+        <div class="search-container">
+            <h1>Que cherchez-vous ?</h1>
+
+            <form id="searchForm">
+                <div class="input-wrapper">
+                    <!-- Scalable Vector Graphic Search Icon -->
+                    <div class="search-icon">
+                        <svg width="20" height="20" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
+                                d="M21 21l-6-6m2-5a7 7 0 11-14 0 7 7 0 0114 0z"></path>
+                        </svg>
+                    </div>
+
+                    <input type="text" id="query" placeholder="Rechercher sur le Togo..." autocomplete="off" required />
+
+                    <select id="pays">
+                        <option value="">Tout</option>
+                        <option value="Togo" selected>Togo</option>
+                        <option value="Sénégal">Sénégal</option>
+                        <option value="Mali">Mali</option>
+                    </select>
+                </div>
+            </form>
+
+            <div class="shortcuts">
+                Appuyez sur <strong>Entrée</strong> pour rechercher
+            </div>
+        </div>
+
+        <div id="results"></div>
+    </main>
+
+    <script>
+        const form = document.getElementById('searchForm');
+        const queryInput = document.getElementById('query');
+        const resultsDiv = document.getElementById('results');
+
+        // Focus input on load
+        window.addEventListener('load', () => queryInput.focus());
+
+        // Reset App State
+        function resetApp() {
+            document.body.classList.remove('has-results');
+            resultsDiv.innerHTML = '';
+            queryInput.value = '';
+            queryInput.focus();
+        }
+
+        form.onsubmit = async function (e) {
+            e.preventDefault();
+            const q = queryInput.value.trim();
+            const pays = document.getElementById('pays').value;
+
+            if (!q) return;
+
+            // Transition UI
+            document.body.classList.add('has-results');
+
+            // Loading State (Skeleton or Spinner equivalent)
+            resultsDiv.innerHTML = `
+                <div style="text-align:center; padding: 40px; color: #444;">
+                    <svg width="30" height="30" viewBox="0 0 50 50" style="animation: spin 1s linear infinite;">
+                        <circle cx="25" cy="25" r="20" fill="none" stroke="#333" stroke-width="4"></circle>
+                        <circle cx="25" cy="25" r="20" fill="none" stroke="#fff" stroke-width="4" stroke-dasharray="80" stroke-dashoffset="60"></circle>
+                    </svg>
+                    <style>@keyframes spin { 100% { transform: rotate(360deg); } }</style>
+                </div>
+            `;
+
+            let url = `http://localhost:8000/search?q=${encodeURIComponent(q)}`;
+            if (pays) url += `&pays=${encodeURIComponent(pays)}`;
+
+            try {
+                const res = await fetch(url);
+                const data = await res.json();
+
+                // Clear loading
+                resultsDiv.innerHTML = "";
+
+                if (data.length === 0) {
+                    resultsDiv.innerHTML = `
+                        <div style="text-align:center; color:#555; padding-top:40px;">
+                            <p>Aucun résultat trouvé pour "${q}"</p>
+                        </div>`;
+                    return;
+                }
+
+                // Render Results with Animation Delay
+                data.forEach((hit, index) => {
+                    const doc = hit.document || hit;
+                    const domain = new URL(doc.source_url).hostname.replace('www.', '');
+
+                    const card = document.createElement('div');
+                    card.className = 'result-card';
+                    card.style.animationDelay = `${index * 0.05}s`;
+
+                    // Truncate text intelligently
+                    const snippet = doc.texte.length > 250 ? doc.texte.substring(0, 250) + "..." : doc.texte;
+
+                    card.innerHTML = `
+                        <div class="source-pill">
+                            <span class="source-icon"></span>
+                            <span>${domain}</span>
+                        </div>
+                        <a href="${doc.source_url}" target="_blank" style="text-decoration:none;">
+                            <h3>${doc.titre}</h3>
+                        </a>
+                        <p>${snippet}</p>
+                        <div class="meta-tag">
+                            ${doc.pays} • ${new Date(doc.date).toLocaleDateString()}
+                        </div>
+                    `;
+                    resultsDiv.appendChild(card);
+                });
+
+            } catch (err) {
+                console.error(err);
+                resultsDiv.innerHTML = `
+                    <div style="color:#ef4444; text-align:center; padding:20px;">
+                        Erreur de connexion au serveur.
+                    </div>`;
+            }
+        }
+    </script>
+</body>
+
+</html>

frontend_example.html

@@ -0,0 +1,372 @@
+<!DOCTYPE html>
+<html lang="fr">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Scrap-Dji - Exemple Frontend</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            padding: 20px;
+        }
+
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+            background: white;
+            border-radius: 20px;
+            padding: 40px;
+            box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
+        }
+
+        h1 {
+            color: #333;
+            margin-bottom: 10px;
+            font-size: 2.5em;
+        }
+
+        .subtitle {
+            color: #666;
+            margin-bottom: 30px;
+            font-size: 1.1em;
+        }
+
+        .search-box {
+            display: flex;
+            gap: 10px;
+            margin-bottom: 20px;
+        }
+
+        input[type="text"] {
+            flex: 1;
+            padding: 15px 20px;
+            border: 2px solid #ddd;
+            border-radius: 10px;
+            font-size: 16px;
+            transition: border-color 0.3s;
+        }
+
+        input[type="text"]:focus {
+            outline: none;
+            border-color: #667eea;
+        }
+
+        button {
+            padding: 15px 30px;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            border: none;
+            border-radius: 10px;
+            font-size: 16px;
+            font-weight: bold;
+            cursor: pointer;
+            transition: transform 0.2s;
+        }
+
+        button:hover {
+            transform: translateY(-2px);
+        }
+
+        button:active {
+            transform: translateY(0);
+        }
+
+        .filters {
+            display: flex;
+            gap: 15px;
+            margin-bottom: 30px;
+            flex-wrap: wrap;
+        }
+
+        select,
+        .checkbox-label {
+            padding: 10px 15px;
+            border: 2px solid #ddd;
+            border-radius: 8px;
+            font-size: 14px;
+        }
+
+        .checkbox-label {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            cursor: pointer;
+        }
+
+        .stats {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 20px;
+            margin-bottom: 30px;
+        }
+
+        .stat-card {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 20px;
+            border-radius: 10px;
+            text-align: center;
+        }
+
+        .stat-value {
+            font-size: 2em;
+            font-weight: bold;
+            margin-bottom: 5px;
+        }
+
+        .stat-label {
+            font-size: 0.9em;
+            opacity: 0.9;
+        }
+
+        .results {
+            margin-top: 30px;
+        }
+
+        .result-item {
+            background: #f8f9fa;
+            padding: 20px;
+            border-radius: 10px;
+            margin-bottom: 15px;
+            border-left: 4px solid #667eea;
+            transition: transform 0.2s;
+        }
+
+        .result-item:hover {
+            transform: translateX(5px);
+        }
+
+        .result-title {
+            font-size: 1.3em;
+            color: #333;
+            margin-bottom: 10px;
+            font-weight: bold;
+        }
+
+        .result-meta {
+            color: #666;
+            font-size: 0.9em;
+            margin-bottom: 10px;
+        }
+
+        .result-excerpt {
+            color: #444;
+            line-height: 1.6;
+            margin-bottom: 10px;
+        }
+
+        .result-link {
+            color: #667eea;
+            text-decoration: none;
+            font-weight: bold;
+        }
+
+        .result-link:hover {
+            text-decoration: underline;
+        }
+
+        .loading {
+            text-align: center;
+            padding: 40px;
+            color: #666;
+        }
+
+        .error {
+            background: #fee;
+            color: #c33;
+            padding: 15px;
+            border-radius: 8px;
+            margin-bottom: 20px;
+        }
+
+        .badge {
+            display: inline-block;
+            padding: 4px 10px;
+            background: #667eea;
+            color: white;
+            border-radius: 12px;
+            font-size: 0.8em;
+            margin-right: 5px;
+        }
+    </style>
+</head>
+
+<body>
+    <div class="container">
+        <h1>🌍 Scrap-Dji</h1>
+        <p class="subtitle">Base de Connaissance Panafricaine - Recherche Intelligente</p>
+
+        <!-- Statistiques -->
+        <div class="stats" id="stats">
+            <div class="stat-card">
+                <div class="stat-value" id="total-docs">-</div>
+                <div class="stat-label">Documents</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value" id="total-pays">-</div>
+                <div class="stat-label">Pays</div>
+            </div>
+            <div class="stat-card">
+                <div class="stat-value" id="total-sources">-</div>
+                <div class="stat-label">Sources</div>
+            </div>
+        </div>
+
+        <!-- Recherche -->
+        <div class="search-box">
+            <input type="text" id="search-input"
+                placeholder="Recherchez des articles (ex: économie togo, politique bénin...)"
+                onkeypress="if(event.key==='Enter') search()">
+            <button onclick="search()">🔍 Rechercher</button>
+        </div>
+
+        <!-- Filtres -->
+        <div class="filters">
+            <select id="pays-filter">
+                <option value="">Tous les pays</option>
+                <option value="Togo">Togo</option>
+                <option value="Bénin">Bénin</option>
+                <option value="Afrique">Afrique</option>
+            </select>
+
+            <select id="langue-filter">
+                <option value="">Toutes les langues</option>
+                <option value="fr">Français</option>
+                <option value="en">English</option>
+            </select>
+
+            <label class="checkbox-label">
+                <input type="checkbox" id="fuzzy-checkbox" checked>
+                Recherche permissive (tolérance aux fautes)
+            </label>
+        </div>
+
+        <!-- Résultats -->
+        <div class="results" id="results"></div>
+    </div>
+
+    <script>
+        // ⚠️ REMPLACEZ PAR L'URL DE VOTRE SPACE HUGGING FACE
+        const API_URL = 'http://localhost:7860';  // Pour test local
+        // const API_URL = 'https://VOTRE_USERNAME-scrap-dji.hf.space';  // Pour production
+
+        // Charger les statistiques au démarrage
+        loadStats();
+
+        async function loadStats() {
+            try {
+                const response = await fetch(`${API_URL}/api/stats`);
+                const data = await response.json();
+
+                document.getElementById('total-docs').textContent = data.total_documents;
+                document.getElementById('total-pays').textContent = Object.keys(data.pays).length;
+                document.getElementById('total-sources').textContent = Object.keys(data.sources).length;
+            } catch (error) {
+                console.error('Erreur chargement stats:', error);
+            }
+        }
+
+        async function search() {
+            const query = document.getElementById('search-input').value.trim();
+            if (!query) {
+                alert('Veuillez entrer une requête de recherche');
+                return;
+            }
+
+            const pays = document.getElementById('pays-filter').value;
+            const langue = document.getElementById('langue-filter').value;
+            const fuzzy = document.getElementById('fuzzy-checkbox').checked;
+
+            const resultsDiv = document.getElementById('results');
+            resultsDiv.innerHTML = '<div class="loading">🔍 Recherche en cours...</div>';
+
+            try {
+                const response = await fetch(`${API_URL}/api/search`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        query: query,
+                        pays: pays || null,
+                        langue: langue || null,
+                        limit: 20,
+                        fuzzy: fuzzy
+                    })
+                });
+
+                if (!response.ok) {
+                    throw new Error(`Erreur HTTP: ${response.status}`);
+                }
+
+                const data = await response.json();
+                displayResults(data);
+
+            } catch (error) {
+                resultsDiv.innerHTML = `
+                    <div class="error">
+                        ❌ Erreur lors de la recherche: ${error.message}
+                        <br><br>
+                        Vérifiez que l'API est accessible à l'adresse: ${API_URL}
+                    </div>
+                `;
+            }
+        }
+
+        function displayResults(data) {
+            const resultsDiv = document.getElementById('results');
+
+            if (data.total === 0) {
+                resultsDiv.innerHTML = `
+                    <div class="loading">
+                        ❌ Aucun résultat trouvé pour "${data.query}"
+                        <br><br>
+                        Essayez avec d'autres mots-clés ou activez la recherche permissive
+                    </div>
+                `;
+                return;
+            }
+
+            let html = `
+                <h2>📊 ${data.total} résultat(s) trouvé(s) en ${data.execution_time_ms}ms</h2>
+                <p style="color: #666; margin-bottom: 20px;">Requête: "${data.query}"</p>
+            `;
+
+            data.results.forEach((result, index) => {
+                const titre = result.titre || 'Sans titre';
+                const texte = result.texte || '';
+                const excerpt = texte.substring(0, 200) + (texte.length > 200 ? '...' : '');
+                const pays = result.pays || 'Inconnu';
+                const langue = result.langue || 'fr';
+                const source = result.source_url || '#';
+                const score = result._score || 0;
+
+                html += `
+                    <div class="result-item">
+                        <div class="result-title">${index + 1}. ${titre}</div>
+                        <div class="result-meta">
+                            <span class="badge">${pays}</span>
+                            <span class="badge">${langue.toUpperCase()}</span>
+                            <span class="badge">Score: ${score.toFixed(1)}</span>
+                        </div>
+                        <div class="result-excerpt">${excerpt}</div>
+                        <a href="${source}" target="_blank" class="result-link">🔗 Lire l'article complet</a>
+                    </div>
+                `;
+            });
+
+            resultsDiv.innerHTML = html;
+        }
+    </script>
+</body>
+
+</html>

indexer/__init__.py

@@ -0,0 +1 @@
+# Module d'indexation : Typesense, Qdrant, FAISS 

indexer/qdrant_indexer.py

@@ -0,0 +1,24 @@
+from qdrant_client import QdrantClient
+from utils.config import QDRANT_HOST, QDRANT_PORT
+
+client = QdrantClient(host=QDRANT_HOST, port=int(QDRANT_PORT))
+
+def create_collection_if_not_exists(collection_name, vector_size):
+    try:
+        client.create_collection(
+            collection_name=collection_name,
+            vectors_config={"size": vector_size, "distance": "Cosine"}
+        )
+    except Exception as e:
+        if 'already exists' not in str(e):
+            raise
+
+def index_embedding(collection_name, embedding, payload, id=None):
+    return client.upsert(
+        collection_name=collection_name,
+        points=[{
+            "id": id,
+            "vector": embedding,
+            "payload": payload
+        }]
+    ) 

indexer/typesense_indexer.py

@@ -0,0 +1,30 @@
+import typesense
+from utils.config import TYPESENSE_HOST, TYPESENSE_PORT, TYPESENSE_API_KEY
+
+client = typesense.Client({
+    'nodes': [{
+        'host': TYPESENSE_HOST,
+        'port': int(TYPESENSE_PORT),
+        'protocol': 'http'
+    }],
+    'api_key': TYPESENSE_API_KEY,
+    'connection_timeout_seconds': 2
+})
+
+def create_collection_if_not_exists(schema):
+    try:
+        # Check existence first to avoid exception cost
+        name = schema.get('name')
+        if name:
+            try:
+                client.collections[name].retrieve()
+                return
+            except Exception:
+                pass
+        client.collections.create(schema)
+    except Exception as e:
+        if 'already exists' not in str(e):
+            raise
+
+def index_document(collection, document):
+    return client.collections[collection].documents.upsert(document) 

parser/__init__.py

@@ -0,0 +1 @@
+# Module de parsing : nettoyage, enrichissement, hashing 

parser/cleaner.py

@@ -0,0 +1,9 @@
+import re
+from bs4 import BeautifulSoup
+
+def clean_html(raw_html: str) -> str:
+    """Supprime les balises HTML et normalise le texte."""
+    soup = BeautifulSoup(raw_html, "html.parser")
+    text = soup.get_text(separator=" ")
+    text = re.sub(r"\s+", " ", text).strip()
+    return text 

parser/hasher.py

@@ -0,0 +1,7 @@
+import hashlib
+
+def hash_text(text: str) -> str:
+    return hashlib.sha256(text.encode('utf-8')).hexdigest()
+
+def hash_bytes(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest() 

render.yaml

@@ -0,0 +1,37 @@
+services:
+  - type: web
+    name: scrap-dji-api
+    env: python
+    plan: free
+    buildCommand: pip install -r requirements.txt
+    startCommand: uvicorn api.main:app --host 0.0.0.0 --port $PORT
+    envVars:
+      - key: TYPESENSE_HOST
+        value: your-typesense-host
+      - key: TYPESENSE_PORT
+        value: 8108
+      - key: TYPESENSE_API_KEY
+        value: xyz
+      - key: STORAGE_PATH
+        value: /tmp/storage_data
+
+  - type: worker
+    name: scrap-dji-worker
+    env: python
+    plan: free
+    buildCommand: pip install -r requirements.txt
+    startCommand: python workers/scraper_worker.py
+    envVars:
+      - key: TYPESENSE_HOST
+        value: your-typesense-host
+      - key: TYPESENSE_PORT
+        value: 8108
+      - key: TYPESENSE_API_KEY
+        value: xyz
+      - key: SCRAPER_INTERVAL
+        value: 300
+
+staticSites:
+  - name: scrap-dji-frontend
+    buildCommand: ''
+    publishPath: frontend

requirements.txt

@@ -0,0 +1,34 @@
+# ============================================================================
+# DÉPENDANCES OPTIMISÉES POUR HUGGING FACE SPACES
+# ============================================================================
+
+# Web Framework
+fastapi==0.109.0
+uvicorn[standard]==0.27.0
+gradio==4.44.0
+
+# HTTP Client
+httpx==0.26.0
+
+# Scraping
+newspaper3k==0.2.8
+beautifulsoup4==4.12.3
+lxml==5.1.0
+lxml_html_clean==0.1.1
+feedparser==6.0.11
+
+# NLP & Text Processing
+nltk==3.8.1
+langdetect==1.0.9
+textblob==0.18.0
+
+# Utilities
+python-dotenv==1.0.1
+pydantic==2.5.3
+aiofiles==23.2.1
+
+# Data Processing
+python-multipart==0.0.9
+
+# Logging (optionnel, Python a déjà logging)
+# colorlog==6.8.2

run_scraper.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""
+Script de lancement pour le scraping Scrap-Dji
+"""
+
+import os
+import sys
+import argparse
+from pathlib import Path
+
+# Ajout du répertoire racine au path
+sys.path.append(str(Path(__file__).parent))
+
+def check_environment():
+    """Vérifie l'environnement avant lancement"""
+    print("🔍 Vérification de l'environnement...")
+    
+    # Vérification du fichier .env
+    if not os.path.exists(".env"):
+        print("❌ Fichier .env manquant")
+        print("   Copiez config.env.example vers .env et configurez-le")
+        return False
+    
+    # Vérification des sources
+    if not os.path.exists("sources.json"):
+        print("❌ Fichier sources.json manquant")
+        print("   Copiez sources.json.example vers sources.json et configurez vos sources")
+        return False
+    
+    # Vérification des répertoires
+    directories = ["storage_data", "logs"]
+    for directory in directories:
+        Path(directory).mkdir(exist_ok=True)
+    
+    print("✅ Environnement OK")
+    return True
+
+def run_scraping(sources_file: str = "sources.json", dry_run: bool = False):
+    """Lance le scraping"""
+    try:
+        from scraper.main import ScrapDjiScraper
+        
+        if dry_run:
+            print("🧪 Mode test - aucun document ne sera sauvegardé")
+            # TODO: Implémenter le mode dry_run
+            return
+        
+        scraper = ScrapDjiScraper(sources_file)
+        total_docs = scraper.run_scraping()
+        
+        print(f"\n🎉 Scraping terminé avec succès!")
+        print(f"📊 {total_docs} documents traités")
+        
+    except ImportError as e:
+        print(f"❌ Erreur d'import: {e}")
+        print("   Vérifiez que toutes les dépendances sont installées")
+    except Exception as e:
+        print(f"❌ Erreur lors du scraping: {e}")
+
+def main():
+    parser = argparse.ArgumentParser(description="Scrap-Dji - Lancement du scraping")
+    parser.add_argument("--sources", "-s", default="sources.json", 
+                       help="Fichier de configuration des sources")
+    parser.add_argument("--dry-run", "-d", action="store_true",
+                       help="Mode test sans sauvegarde")
+    parser.add_argument("--setup", action="store_true",
+                       help="Lance la configuration initiale")
+    
+    args = parser.parse_args()
+    
+    if args.setup:
+        print("🔧 Lancement de la configuration...")
+        os.system("python setup.py")
+        return
+    
+    print("🚀 Scrap-Dji - Lancement du scraping")
+    print("=" * 50)
+    
+    if not check_environment():
+        sys.exit(1)
+    
+    run_scraping(args.sources, args.dry_run)
+
+if __name__ == "__main__":
+    main() 

scrape_togo_massive.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""
+Script de scraping massif pour le Togo
+Collecte des données depuis toutes les sources togolaises configurées
+"""
+
+import asyncio
+import sys
+from pathlib import Path
+
+# Ajout du répertoire racine au path
+sys.path.append(str(Path(__file__).parent))
+
+from scraper.main import ScrapDjiScraper
+from utils.logger import setup_logger
+import json
+
+logger = setup_logger(__name__)
+
+def print_banner():
+    print("=" * 60)
+    print("🇹🇬  SCRAPING MASSIF - DONNÉES TOGO  🇹🇬")
+    print("=" * 60)
+    print()
+
+def print_stats(data_file: str = "data/search_index.json"):
+    """Affiche les statistiques de scraping"""
+    try:
+        with open(data_file, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        
+        total = len(data)
+        togo_docs = [d for d in data if d.get('pays') == 'Togo']
+        
+        print("\n" + "=" * 60)
+        print("📊 STATISTIQUES DE SCRAPING")
+        print("=" * 60)
+        print(f"📄 Total de documents collectés: {total}")
+        print(f"🇹🇬 Documents sur le Togo: {len(togo_docs)}")
+        
+        if togo_docs:
+            # Statistiques par source
+            sources = {}
+            for doc in togo_docs:
+                url = doc.get('source_url', '')
+                domain = url.split('/')[2] if len(url.split('/')) > 2 else 'unknown'
+                sources[domain] = sources.get(domain, 0) + 1
+            
+            print("\n📰 Répartition par source:")
+            for source, count in sorted(sources.items(), key=lambda x: x[1], reverse=True):
+                print(f"   • {source}: {count} articles")
+        
+        print("=" * 60)
+        print()
+        
+    except FileNotFoundError:
+        print("⚠️  Aucune donnée trouvée. Le scraping va commencer...")
+    except Exception as e:
+        logger.error(f"Erreur lecture stats: {e}")
+
+async def main():
+    print_banner()
+    
+    # Vérifier la configuration
+    if not Path("sources.json").exists():
+        print("❌ Fichier sources.json manquant!")
+        return
+    
+    # Afficher les sources configurées
+    with open("sources.json", 'r', encoding='utf-8') as f:
+        config = json.load(f)
+    
+    sources = config.get('sources', [])
+    active_sources = [s for s in sources if s.get('active', True)]
+    togo_sources = [s for s in active_sources if s.get('pays') == 'Togo']
+    
+    print(f"🎯 Sources togolaises actives: {len(togo_sources)}")
+    for source in togo_sources:
+        print(f"   • {source['name']} - {source['url']}")
+    print()
+    
+    # Stats avant scraping
+    print_stats()
+    
+    # Lancer le scraping
+    print("🚀 Démarrage du scraping massif...")
+    print("⏳ Cela peut prendre plusieurs minutes...\n")
+    
+    scraper = ScrapDjiScraper("sources.json")
+    await scraper.run()
+    
+    # Stats après scraping
+    print("\n✅ Scraping terminé!")
+    print_stats()
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        print("\n\n⚠️  Scraping interrompu par l'utilisateur")
+        print_stats()
+    except Exception as e:
+        logger.error(f"Erreur fatale: {e}")
+        print(f"\n❌ Erreur: {e}")

scraper/__init__.py

@@ -0,0 +1 @@
+# Module de scraping : extraction web, réseaux sociaux, documents 

scraper/discovery.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+"""
+Module de découverte unifié et optimisé pour Scrap-Dji
+Conçu pour être rapide et économe en ressources (Async/Httpx)
+"""
+
+import asyncio
+import httpx
+import json
+import re
+import os
+from urllib.parse import urljoin, urlparse
+from typing import List, Dict, Set
+from bs4 import BeautifulSoup
+from datetime import datetime
+
+from utils.logger import setup_logger
+from utils.config import SCRAPER_DELAY, SCRAPER_USER_AGENT
+
+logger = setup_logger(__name__)
+
+class UnifiedDiscovery:
+    def __init__(self):
+        self.headers = {'User-Agent': SCRAPER_USER_AGENT}
+        self.african_domains = {'.sn', '.ml', '.ci', '.ng', '.gh', '.ke', '.ma', '.tn', '.dz', '.cm', '.cd', '.ga', '.bj', '.tg'}
+        self.seed_sources = [
+            "https://www.allafrica.com",
+            "https://www.africanews.com",
+            "https://www.bbc.com/africa",
+            "https://www.rfi.fr/fr/afrique"
+        ]
+        self.african_keywords = ['afrique', 'africa', 'actualités', 'news', 'journal', 'presse']
+
+    async def is_african_site(self, client: httpx.AsyncClient, url: str) -> bool:
+        """Vérification rapide (Domaine) puis analyse de contenu si nécessaire"""
+        domain = urlparse(url).netloc.lower()
+        if any(domain.endswith(ext) for ext in self.african_domains):
+            return True
+        
+        try:
+            resp = await client.get(url, timeout=5.0)
+            if resp.status_code == 200:
+                text = resp.text.lower()
+                return sum(text.count(kw) for kw in self.african_keywords) > 3
+        except Exception:
+            pass
+        return False
+
+    async def explore_source(self, client: httpx.AsyncClient, seed_url: str) -> List[Dict]:
+        """Explore une source de départ asynchronement"""
+        discovered = []
+        try:
+            logger.info(f"🔍 Exploration de {seed_url}...")
+            resp = await client.get(seed_url, timeout=10.0)
+            soup = BeautifulSoup(resp.content, 'lxml')
+            
+            links = soup.find_all('a', href=True)
+            for link in links:
+                href = link.get('href')
+                if not href or not href.startswith('http'): continue
+                
+                full_url = urljoin(seed_url, href)
+                domain = urlparse(full_url).netloc
+                
+                if any(ext in domain for ext in self.african_domains):
+                    discovered.append({
+                        'name': domain.replace('.', '_'),
+                        'url': f"{urlparse(full_url).scheme}://{domain}",
+                        'type': 'news',
+                        'active': True,
+                        'discovered_at': datetime.now().isoformat()
+                    })
+        except Exception as e:
+            logger.error(f"Erreur seed {seed_url}: {e}")
+        return discovered
+
+    async def run_discovery(self):
+        async with httpx.AsyncClient(headers=self.headers, follow_redirects=True) as client:
+            tasks = [self.explore_source(client, seed) for seed in self.seed_sources]
+            results = await asyncio.gather(*tasks)
+            
+            all_sources = []
+            seen = set()
+            for batch in results:
+                for s in batch:
+                    if s['url'] not in seen:
+                        all_sources.append(s)
+                        seen.add(s['url'])
+            
+            logger.info(f"✅ {len(all_sources)} sources uniques découvertes.")
+            self.save_sources(all_sources)
+            return all_sources
+
+    def save_sources(self, sources: List[Dict], filename: str = "sources.json"):
+        existing = {"sources": []}
+        if os.path.exists(filename):
+            try:
+                with open(filename, 'r', encoding='utf-8') as f:
+                    existing = json.load(f)
+            except: pass
+        
+        existing_urls = {s['url'] for s in existing.get('sources', [])}
+        new_sources = [s for s in sources if s['url'] not in existing_urls]
+        
+        existing['sources'].extend(new_sources)
+        
+        with open(filename, 'w', encoding='utf-8') as f:
+            json.dump(existing, f, indent=2, ensure_ascii=False)
+        logger.info(f"💾 {len(new_sources)} nouvelles sources ajoutées à {filename}")
+
+if __name__ == "__main__":
+    discovery = UnifiedDiscovery()
+    asyncio.run(discovery.run_discovery())

scraper/main.py

@@ -0,0 +1,186 @@
+import asyncio
+import httpx
+import json
+import logging
+from typing import Dict, List, Optional
+from datetime import datetime
+from lxml import html
+from newspaper import Article
+
+from utils.config import STORAGE_PATH, SCRAPER_DELAY, SCRAPER_CONCURRENT_REQUESTS
+from utils.logger import setup_logger
+from db.postgres_connector import SessionLocal
+from db.models import Document, DocumentVersion
+from db.mongo_connector import save_to_mongo
+from parser.cleaner import clean_html
+from indexer.typesense_indexer import index_document as index_typesense
+from utils.uuid_gen import generate_uuid
+
+logger = setup_logger(__name__)
+
+class ScrapDjiScraper:
+    def __init__(self, sources_file: str = "sources.json"):
+        self.sources_file = sources_file
+        self.sources = self.load_sources()
+        self.sem = asyncio.Semaphore(10)  # Augmenté pour scraping massif
+        self.buffer = []
+        self.buffer_size = 50  # Buffer augmenté pour scraping massif
+        self.discovered_urls = set()  # Pour éviter les doublons
+
+    def load_sources(self) -> Dict:
+        if not os.path.exists(self.sources_file):
+            return {"sources": []}
+        with open(self.sources_file, 'r', encoding='utf-8') as f:
+            return json.load(f)
+
+    async def scrape_article(self, client: httpx.AsyncClient, source: Dict, url: str) -> Optional[Dict]:
+        """Scrape ultra-rapide avec lxml (C-level parsing)"""
+        try:
+            resp = await client.get(url, timeout=7.0)
+            if resp.status_code != 200: return None
+            
+            # Utilisation de lxml directement pour la vitesse pure
+            tree = html.fromstring(resp.content)
+            title = tree.xpath('//h1/text()')
+            title = title[0].strip() if title else "Sans titre"
+            
+            # Extraction brute via newspaper (très optimisée)
+            article = Article(url)
+            article.set_html(resp.text)
+            article.parse()
+            content = article.text
+            
+            if len(content) < 100: return None
+            
+            return {
+                'id': generate_uuid(),
+                'titre': title,
+                'texte': content,
+                'source_url': url,
+                'pays': source.get('pays', 'Afrique'),
+                'langue': source.get('langue', 'fr'),
+                'type_document': 'article',
+                'date': datetime.now().isoformat()
+            }
+        except Exception as e:
+            logger.debug(f"Erreur scraping {url}: {e}")
+            return None
+    
+    async def discover_links(self, client: httpx.AsyncClient, base_url: str) -> List[str]:
+        """Découvre les liens d'articles sur une page"""
+        try:
+            resp = await client.get(base_url, timeout=10.0)
+            if resp.status_code != 200:
+                return []
+            
+            tree = html.fromstring(resp.content)
+            # Extraction de tous les liens d'articles
+            links = tree.xpath('//a/@href')
+            
+            # Filtrage et normalisation des URLs
+            article_urls = []
+            for link in links:
+                if not link:
+                    continue
+                # Construire l'URL complète
+                if link.startswith('/'):
+                    from urllib.parse import urljoin
+                    link = urljoin(base_url, link)
+                elif not link.startswith('http'):
+                    continue
+                
+                # Filtrer les URLs qui ressemblent à des articles
+                if any(x in link.lower() for x in ['article', 'actualite', 'news', '/20', '-20']):
+                    if link not in self.discovered_urls:
+                        article_urls.append(link)
+                        self.discovered_urls.add(link)
+            
+            return article_urls[:100]  # Limiter à 100 liens par page
+        except Exception as e:
+            logger.debug(f"Erreur découverte liens {base_url}: {e}")
+            return []
+
+    async def flush_buffer(self):
+        """Sauvegarde groupée pour réduire les accès disque/réseau"""
+        if not self.buffer: return
+        logger.info(f"💾 Flush buffer: sauvegarde de {len(self.buffer)} documents...")
+        tasks = [self.save_everywhere(doc) for doc in self.buffer]
+        await asyncio.gather(*tasks)
+        self.buffer = []
+
+    async def save_everywhere(self, doc: Dict):
+        # Fallback de secours : Toujours sauver en local JSON pour le test
+        try:
+            os.makedirs("data", exist_ok=True)
+            local_file = "data/search_index.json"
+            data = []
+            if os.path.exists(local_file):
+                with open(local_file, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+            data.append(doc)
+            # Garder tous les documents pour scraping massif
+            with open(local_file, "w", encoding="utf-8") as f:
+                json.dump(data, f, indent=2, ensure_ascii=False)
+        except Exception as e:
+            logger.error(f"Erreur sauvegarde JSON locale: {e}")
+
+        # Les autres bases (échoueront silencieusement si non installées)
+        try:
+            session = SessionLocal()
+            new_doc = Document(**{k: v for k, v in doc.items() if k in Document.__table__.columns})
+            session.add(new_doc)
+            session.commit()
+            session.close()
+        except: pass 
+        
+        try: await save_to_mongo("documents", doc)
+        except: pass
+        try: index_typesense("documents", doc)
+        except: pass
+
+    async def process_source(self, client: httpx.AsyncClient, source: Dict):
+        """Traite une source avec découverte de liens"""
+        count = 0
+        async with self.sem:
+            try:
+                # 1. Scraper la page principale
+                doc = await self.scrape_article(client, source, source['url'])
+                if doc:
+                    self.buffer.append(doc)
+                    count += 1
+                
+                # 2. Découvrir et scraper les articles liés
+                logger.info(f"🔍 Découverte de liens sur {source['name']}...")
+                article_urls = await self.discover_links(client, source['url'])
+                logger.info(f"📰 {len(article_urls)} articles découverts sur {source['name']}")
+                
+                # 3. Scraper les articles découverts (avec limite)
+                for url in article_urls[:50]:  # Limiter à 50 articles par source pour commencer
+                    doc = await self.scrape_article(client, source, url)
+                    if doc:
+                        self.buffer.append(doc)
+                        count += 1
+                        if len(self.buffer) >= self.buffer_size:
+                            await self.flush_buffer()
+                    await asyncio.sleep(0.5)  # Petit délai pour ne pas surcharger
+                
+                return count
+            except Exception as e:
+                logger.error(f"Erreur traitement source {source.get('name')}: {e}")
+                return count
+
+    async def run(self):
+        active_sources = [s for s in self.sources.get('sources', []) if s.get('active', True)]
+        # Utilisation de HTTP/2 pour plus de vitesse si supporté par le site
+        async with httpx.AsyncClient(timeout=10.0, follow_redirects=True, http2=True) as client:
+            tasks = [self.process_source(client, s) for s in active_sources]
+            counts = await asyncio.gather(*tasks)
+            await self.flush_buffer() # Dernier flush
+            logger.info(f"⚡ Turbo Scraping terminé. {sum(counts)} documents traités.")
+
+import os
+from datetime import datetime
+
+if __name__ == "__main__":
+    scraper = ScrapDjiScraper()
+    asyncio.run(scraper.run())

scraper/rss.py

@@ -0,0 +1,57 @@
+import feedparser
+from datetime import datetime
+from typing import List, Dict
+from parser.cleaner import clean_html
+from parser.hasher import hash_text
+from indexer.typesense_indexer import create_collection_if_not_exists, index_document
+
+SCHEMA = {
+    "name": "documents",
+    "fields": [
+        {"name": "id", "type": "string"},
+        {"name": "titre", "type": "string"},
+        {"name": "texte", "type": "string"},
+        {"name": "langue", "type": "string", "facet": True},
+        {"name": "type_document", "type": "string", "facet": True},
+        {"name": "pays", "type": "string", "facet": True},
+        {"name": "source_url", "type": "string"},
+        {"name": "date", "type": "string"}
+    ]
+}
+
+def fetch_and_index_feeds(feed_urls: List[str]) -> Dict[str, int]:
+    create_collection_if_not_exists(SCHEMA)
+    total, ok = 0, 0
+    for url in feed_urls:
+        parsed = feedparser.parse(url)
+        for entry in parsed.entries:
+            total += 1
+            title = entry.get('title', '')
+            link = entry.get('link', '')
+            summary = entry.get('summary', '') or entry.get('description', '')
+            content = summary
+            text = clean_html(content)
+            if not text and title:
+                text = title
+            if not text:
+                continue
+            # Déduplication stable
+            doc_id = hash_text((link or title) + '|' + text)[:16]
+            doc = {
+                "id": doc_id,
+                "titre": title or link,
+                "texte": text[:8000],
+                "langue": "fr",  # best effort; détection langue à ajouter
+                "type_document": "rss",
+                "pays": "",  # enrichissement géo à ajouter
+                "source_url": link,
+                "date": datetime.utcnow().isoformat()
+            }
+            try:
+                index_document("documents", doc)
+                ok += 1
+            except Exception:
+                # on ignore silencieusement pour la robustesse POC
+                pass
+    return {"processed": total, "indexed": ok}
+

scraper/rss_sources.py

@@ -0,0 +1,16 @@
+FEEDS = [
+    # Afrique - actualités
+    "https://www.rfi.fr/fr/afrique/rss",
+    "https://www.aljazeera.com/xml/rss/all.xml",  # contient Afrique, filtrage côté contenu
+    "https://feeds.bbci.co.uk/news/world/africa/rss.xml",
+
+    # Science générale
+    "https://www.nature.com/subjects/artificial-intelligence/rss",
+    "https://www.sciencedaily.com/rss/computers_math/artificial_intelligence.xml",
+
+    # ArXiv - math, IA
+    "https://export.arxiv.org/rss/cs.AI",
+    "https://export.arxiv.org/rss/cs.LG",
+    "https://export.arxiv.org/rss/math",
+]
+

scripts/bootstrap_typesense.py

@@ -0,0 +1,35 @@
+import json
+import os
+from indexer.typesense_indexer import create_collection_if_not_exists, index_document
+
+SCHEMA = {
+    "name": "documents",
+    "fields": [
+        {"name": "id", "type": "string"},
+        {"name": "titre", "type": "string"},
+        {"name": "texte", "type": "string"},
+        {"name": "langue", "type": "string", "facet": True},
+        {"name": "type_document", "type": "string", "facet": True},
+        {"name": "pays", "type": "string", "facet": True},
+        {"name": "source_url", "type": "string"},
+        {"name": "date", "type": "string"}
+    ]
+}
+
+def main():
+    create_collection_if_not_exists(SCHEMA)
+    path = os.environ.get("SEED_JSONL", "datasets/ewe/final/ewe_corpus.jsonl")
+    if os.path.exists(path):
+        with open(path, "r", encoding="utf-8") as f:
+            for line in f:
+                doc = json.loads(line)
+                doc_id = doc.get("uuid") or doc.get("id") or os.urandom(8).hex()
+                doc["id"] = doc_id
+                index_document("documents", doc)
+        print("Seed terminé.")
+    else:
+        print("Aucun fichier de seed trouvé, collection créée sans documents.")
+
+if __name__ == "__main__":
+    main()
+

setup.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+"""
+Script de configuration pour Scrap-Dji
+Initialise les bases de données et les services nécessaires
+"""
+
+import os
+import sys
+import subprocess
+from pathlib import Path
+
+def check_python_version():
+    """Vérifie la version de Python"""
+    if sys.version_info < (3, 10):
+        print("❌ Python 3.10+ requis")
+        sys.exit(1)
+    print("✅ Version Python OK")
+
+def install_dependencies():
+    """Installe les dépendances"""
+    print("📦 Installation des dépendances...")
+    try:
+        subprocess.run([sys.executable, "-m", "pip", "install", "-r", "requirements.txt"], check=True)
+        print("✅ Dépendances installées")
+    except subprocess.CalledProcessError:
+        print("❌ Erreur lors de l'installation des dépendances")
+        sys.exit(1)
+
+def create_directories():
+    """Crée les répertoires nécessaires"""
+    directories = [
+        "storage_data",
+        "logs",
+        "data",
+        "temp"
+    ]
+    
+    for directory in directories:
+        Path(directory).mkdir(exist_ok=True)
+        print(f"✅ Répertoire créé: {directory}")
+
+def setup_env_file():
+    """Configure le fichier .env"""
+    if not os.path.exists(".env"):
+        if os.path.exists("config.env.example"):
+            os.system("copy config.env.example .env")
+            print("✅ Fichier .env créé (à configurer)")
+        else:
+            print("⚠️  Créez un fichier .env basé sur config.env.example")
+    else:
+        print("✅ Fichier .env existe déjà")
+
+def init_databases():
+    """Initialise les bases de données"""
+    print("🗄️  Initialisation des bases de données...")
+    try:
+        from db.postgres_connector import init_db
+        init_db()
+        print("✅ Base PostgreSQL initialisée")
+    except Exception as e:
+        print(f"⚠️  Erreur PostgreSQL: {e}")
+        print("   Assurez-vous que PostgreSQL est installé et configuré")
+
+def check_services():
+    """Vérifie les services requis"""
+    services = {
+        "PostgreSQL": "postgresql://localhost:5432",
+        "MongoDB": "mongodb://localhost:27017",
+        "Typesense": "http://localhost:8108",
+        "Qdrant": "http://localhost:6333"
+    }
+    
+    print("🔍 Vérification des services...")
+    for service, url in services.items():
+        try:
+            # Vérification basique
+            print(f"   {service}: {'✅' if 'localhost' in url else '⚠️'}")
+        except:
+            print(f"   {service}: ❌")
+
+def main():
+    print("🚀 Configuration de Scrap-Dji")
+    print("=" * 40)
+    
+    check_python_version()
+    install_dependencies()
+    create_directories()
+    setup_env_file()
+    init_databases()
+    check_services()
+    
+    print("\n" + "=" * 40)
+    print("✅ Configuration terminée!")
+    print("\n📋 Prochaines étapes:")
+    print("1. Configurez le fichier .env avec vos paramètres")
+    print("2. Installez et démarrez PostgreSQL, MongoDB, Typesense, Qdrant")
+    print("3. Configurez vos sources dans sources.json")
+    print("4. Lancez le scraping avec: python -m scraper.main")
+
+if __name__ == "__main__":
+    main() 

sources.json

@@ -0,0 +1,108 @@
+{
+  "sources": [
+    {
+      "name": "TogoFirst",
+      "type": "news",
+      "url": "https://www.togofirst.com",
+      "pays": "Togo",
+      "langue": "fr",
+      "active": true
+    },
+    {
+      "name": "27septembre",
+      "type": "news",
+      "url": "https://www.27septembre.com",
+      "pays": "Togo",
+      "langue": "fr",
+      "active": true
+    },
+    {
+      "name": "IciLome",
+      "type": "news",
+      "url": "https://icilome.com",
+      "pays": "Togo",
+      "langue": "fr",
+      "active": true
+    },
+    {
+      "name": "TogoBreakingNews",
+      "type": "news",
+      "url": "https://www.togobreakingnews.info",
+      "pays": "Togo",
+      "langue": "fr",
+      "active": true
+    },
+    {
+      "name": "RepublicOfTogo",
+      "type": "news",
+      "url": "https://www.republicoftogo.com",
+      "pays": "Togo",
+      "langue": "fr",
+      "active": true
+    },
+    {
+      "name": "TogoActualite",
+      "type": "news",
+      "url": "https://togoactualite.com",
+      "pays": "Togo",
+      "langue": "fr",
+      "active": true
+    },
+    {
+      "name": "LomeInfo",
+      "type": "news",
+      "url": "https://www.lomeinfo.net",
+      "pays": "Togo",
+      "langue": "fr",
+      "active": true
+    },
+    {
+      "name": "TogoSite",
+      "type": "news",
+      "url": "https://www.togosite.com",
+      "pays": "Togo",
+      "langue": "fr",
+      "active": true
+    },
+    {
+      "name": "BeninWebTV",
+      "type": "news",
+      "url": "https://beninwebtv.com",
+      "pays": "Bénin",
+      "langue": "fr",
+      "active": true
+    },
+    {
+      "name": "LaNouvelleRepublique",
+      "type": "news",
+      "url": "https://lanouvellerepublique.bj",
+      "pays": "Bénin",
+      "langue": "fr",
+      "active": true
+    },
+    {
+      "name": "BeninActu",
+      "type": "news",
+      "url": "https://beninactu.com",
+      "pays": "Bénin",
+      "langue": "fr",
+      "active": true
+    },
+    {
+      "name": "Matin Libre",
+      "type": "news",
+      "url": "https://www.matinlibre.com",
+      "pays": "Bénin",
+      "langue": "fr",
+      "active": true
+    }
+  ],
+  "settings": {
+    "delay_between_requests": 0.5,
+    "max_pages_per_source": 500,
+    "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+    "concurrent_requests": 10,
+    "buffer_size": 50,
+    "deep_crawl": true
+  }
+}